/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * vim: set ts=8 sts=4 et sw=4 tw=99:
 *
 * gSummaryChart Implementation
 *
 * Copyright (c) 2011-2014 Mark Watkins <jedimark@users.sourceforge.net>
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License. See the file COPYING in the main directory of the Linux
 * distribution for more details. */

#include <math.h>
#include <QLabel>
#include <QDateTime>
#include "gYAxis.h"
#include "gSummaryChart.h"

extern QLabel * qstatus2;
SummaryChart::SummaryChart(QString label,GraphType type)
:Layer(NoChannel),m_label(label),m_graphtype(type)
{
    //QColor color=Qt::black;
    addVertexBuffer(quads=new gVertexBuffer(20000,GL_QUADS));
    addVertexBuffer(lines=new gVertexBuffer(20000,GL_LINES));
    addVertexBuffer(outlines=new gVertexBuffer(20000,GL_LINES));
    addVertexBuffer(points=new gVertexBuffer(20000,GL_POINTS));
    quads->forceAntiAlias(true);

    outlines->setSize(1);

    //lines->setBlendFunc(GL_SRC_COLOR, GL_ZERO);
    //lines->forceAntiAlias(false);

    m_empty=true;
    hl_day=-1;
    m_machinetype=MT_CPAP;

    QDateTime d1=QDateTime::currentDateTime();
    QDateTime d2=d1;
    d1.setTimeSpec(Qt::UTC);
    tz_offset=d2.secsTo(d1);
    tz_hours=tz_offset/3600.0;

}
SummaryChart::~SummaryChart()
{
}
void SummaryChart::SetDay(Day * nullday)
{
    Day * day=nullday;
    Layer::SetDay(day);

    m_values.clear();
    m_times.clear();
    m_days.clear();
    m_hours.clear();
    m_goodcodes.clear();
    m_miny=999999999;
    m_maxy=-999999999;
    m_physmaxy=0;
    m_physminy=0;
    m_minx=0;
    m_maxx=0;


    int dn;
    EventDataType tmp,tmp2,total;
    ChannelID code;
    CPAPMode cpapmode=(CPAPMode)(int)PROFILE.calcSettingsMax(CPAP_Mode,MT_CPAP,PROFILE.FirstDay(MT_CPAP),PROFILE.LastDay(MT_CPAP));
    if (m_label==STR_TR_Pressure) {
        m_codes.clear();
        m_colors.clear();
        m_type.clear();
        m_typeval.clear();

        float perc=PROFILE.general->prefCalcPercentile()/100.0;
        int mididx=PROFILE.general->prefCalcMiddle();
        SummaryType mid;
        if (mididx==0) mid=ST_PERC;
        if (mididx==1) mid=ST_WAVG;
        if (mididx==2) mid=ST_AVG;

        if (cpapmode>=MODE_ASV) {
            addSlice(CPAP_EPAP,QColor("green"),ST_SETMIN);

            addSlice(CPAP_IPAPLo,QColor("light blue"),ST_SETMIN);
            addSlice(CPAP_IPAP,QColor("cyan"),mid,0.5);
            addSlice(CPAP_IPAP,QColor("dark cyan"),ST_PERC,perc);
            //addSlice(CPAP_IPAP,QColor("light blue"),ST_PERC,0.95);
            addSlice(CPAP_IPAPHi,QColor("blue"),ST_SETMAX);
        } else if (cpapmode>=MODE_BIPAP) {
            addSlice(CPAP_EPAP,QColor("green"),ST_SETMIN);
            addSlice(CPAP_EPAP,QColor("light green"),ST_PERC,perc);
            addSlice(CPAP_IPAP,QColor("light cyan"),mid,0.5);
            addSlice(CPAP_IPAP,QColor("light blue"),ST_PERC,perc);
            addSlice(CPAP_IPAP,QColor("blue"),ST_SETMAX);
        } else if (cpapmode>=MODE_APAP) {
            addSlice(CPAP_PressureMin,QColor("orange"),ST_SETMIN);
            addSlice(CPAP_Pressure,QColor("dark green"),mid,0.5);
            addSlice(CPAP_Pressure,QColor("grey"),ST_PERC,perc);
            addSlice(CPAP_PressureMax,QColor("red"),ST_SETMAX);
        } else {
            addSlice(CPAP_Pressure,QColor("dark green"),ST_SETWAVG);
        }
    }

    m_goodcodes.resize(m_codes.size());
    for (int i=0;i<m_codes.size();i++) {
        m_goodcodes[i]=false;
    }

    m_fday=0;
    qint64 tt,zt;
    m_empty=true;
    if (m_graphtype==GT_SESSIONS) {
        if (PROFILE.countDays(MT_CPAP,PROFILE.FirstDay(MT_CPAP), PROFILE.LastDay(MT_CPAP))==0)
            return;
    }
    int suboffset;
    SummaryType type;
    bool first=true;

    for (QMap<QDate,QList<Day *> >::iterator d=PROFILE.daylist.begin();d!=PROFILE.daylist.end();d++) {
        tt=QDateTime(d.key(),QTime(0,0,0),Qt::UTC).toTime_t();
        dn=tt/86400;
        tt*=1000L;
        if (!m_minx || tt<m_minx) m_minx=tt;
        if (!m_maxx || tt>m_maxx) m_maxx=tt;

        total=0;
        bool fnd=false;
        if (m_graphtype==GT_SESSIONS) {
            for (int i=0;i<m_codes.size();i++)
                m_goodcodes[i]=true;
            for (int i=0;i<d.value().size();i++) { // for each day
                day=d.value().at(i);
                if  (!day) continue;
                if (day->machine_type()!=m_machinetype) continue;
                int ft=qint64(day->first())/1000L;
                ft+=tz_offset; // convert to local time

                int dz2=ft/86400;
                dz2*=86400;  // ft = first sessions time, rounded back to midnight..

                for (int s=0;s<day->size();s++) {
                    Session *sess=(*day)[s];
                    if (!sess->enabled()) continue;

                    tmp=sess->hours();
                    m_values[dn][s]=tmp;
                    total+=tmp;
                    zt=qint64(sess->first())/1000L;
                    zt+=tz_offset;
                    tmp2=zt-dn*86400;
                    tmp2/=3600.0;

                    m_times[dn][s]=tmp2;

                    if (first) {
                        m_miny=tmp2;
                        m_maxy=tmp2+tmp;
                        first=false;
                    } else {
                        if (tmp2 < m_miny)
                            m_miny=tmp2;
                        if (tmp2+tmp > m_maxy)
                            m_maxy=tmp2+tmp;
                    }
                }
                if (total>0) {
                    m_days[dn]=day;
                    m_hours[dn]=total;
                    m_empty=false;
                }
            }
        } else {
            for (int j=0;j<m_codes.size();j++) { // for each code slice
                code=m_codes[j];
                suboffset=0;
                type=m_type[j];
                EventDataType typeval=m_typeval[j];
                for (int i=0;i<d.value().size();i++) { // for each machine object for this day
                    day=d.value()[i];
                    CPAPMode mode=(CPAPMode)(int)day->settings_max(CPAP_Mode);
                    if (day->machine_type()!=m_machinetype) continue;

                    bool hascode=//day->channelHasData(code) ||
                            type==ST_HOURS ||
                            type==ST_SESSIONS ||
                            day->settingExists(code) ||
                            day->hasData(code,type);

                    if (code==CPAP_Pressure) {
                        if ((cpapmode>MODE_CPAP) && (mode==MODE_CPAP)) {
                            hascode=false;
                            if ((type==ST_WAVG) || (type==ST_AVG) || ((type==ST_PERC) && (typeval==0.5))) {
                                type=ST_SETWAVG;
                                hascode=true;
                            }
                        } else {
                            type=m_type[j];
                        }
                    }

                    //if (code==CPAP_Hypopnea) { // Make sure at least one of the CPAP data gets through with 0
                    //    hascode=true;
                    //}
                    if (hascode) {
                        m_days[dn]=day;
                        switch(type) {
                            case ST_AVG: tmp=day->avg(code); break;
                            case ST_SUM: tmp=day->sum(code); break;
                            case ST_WAVG: tmp=day->wavg(code); break;
                            case ST_90P: tmp=day->p90(code); break;
                            case ST_PERC: tmp=day->percentile(code,typeval); break;
                            case ST_MIN: tmp=day->Min(code); break;
                            case ST_MAX: tmp=day->Max(code); break;
                            case ST_CNT: tmp=day->count(code); break;
                            case ST_CPH: tmp=day->cph(code); break;
                            case ST_SPH: tmp=day->sph(code); break;
                            case ST_HOURS: tmp=day->hours(); break;
                            case ST_SESSIONS: tmp=day->size(); break;
                            case ST_SETMIN: tmp=day->settings_min(code); break;
                            case ST_SETMAX: tmp=day->settings_max(code); break;
                            case ST_SETAVG: tmp=day->settings_avg(code); break;
                            case ST_SETWAVG: tmp=day->settings_wavg(code); break;
                            case ST_SETSUM: tmp=day->settings_sum(code); break;
                        default:
                            tmp=0;
                            break;
                        }
                        if (suboffset>0) {
                            tmp-=suboffset;
                            if (tmp<0) tmp=0;
                        }
                        total+=tmp;
                        m_values[dn][j+1]=tmp;
                        if (tmp<m_miny) m_miny=tmp;
                        if (tmp>m_maxy) m_maxy=tmp;
                        m_goodcodes[j]=true;
                        fnd=true;
                        break;
                    }
                }
            }
            if (fnd) {
                if (!m_fday) m_fday=dn;
                m_values[dn][0]=total;
                m_hours[dn]=day->hours();
                if (m_graphtype==GT_BAR) {
                    if (total<m_miny) m_miny=total;
                    if (total>m_maxy) m_maxy=total;
                }
           }
        }
    }
    m_empty=true;
    for (int i=0;i<m_goodcodes.size();i++) {
        if (m_goodcodes[i]) {
            m_empty=false;
            break;
        }
    }
    if (m_graphtype==GT_BAR) {
        m_miny=0;
    }
   // m_minx=qint64(QDateTime(PROFILE.FirstDay(),QTime(0,0,0),Qt::UTC).toTime_t())*1000L;
    m_maxx=qint64(QDateTime(PROFILE.LastDay(),QTime(23,59,0),Qt::UTC).toTime_t())*1000L;
    m_physmaxy=m_maxy;
    m_physminy=m_miny;
}

QColor brighten(QColor color)
{
    int cr,cg,cb;

    cr=color.red();
    cg=color.green();
    cb=color.blue();

    if (cr<64) cr=64;
    if (cg<64) cg=64;
    if (cb<64) cb=64;

    cr*=2;
    cg*=2;
    cb*=2;

    if (cr>255) cr=255;
    if (cg>255) cg=255;
    if (cb>255) cb=255;

    return QColor(cr,cg,cb,255);

}

void SummaryChart::paint(gGraph & w,int left, int top, int width, int height)
{
    if (!m_visible) return;

    points->setSize(10);


    GraphType graphtype=m_graphtype;

    if (graphtype==GT_LINE || graphtype==GT_POINTS) {
        bool pts=PROFILE.appearance->overviewLinechartMode()==OLC_Lines;
        graphtype=pts ? GT_POINTS : GT_LINE;
    }

    if (graphtype==GT_POINTS) {
        lines->setSize(4);
    } else
        lines->setSize(1.5);


    rtop=top;
    gVertexBuffer *outlines2=w.lines();
  //  outlines2->setColor(Qt::black);
    outlines2->add(left, top, left, top+height, left, top+height, left+width,top+height,QColor("black").rgba());
    outlines2->add(left+width,top+height, left+width, top, left+width, top, left, top,QColor("black").rgba());
    //if (outlines->full()) qDebug() << "WTF??? Outlines full in SummaryChart::paint()";

    qint64 minx=w.min_x, maxx=w.max_x;
    qint64 xx=maxx - minx;
    float days=double(xx)/86400000.0;


    EventDataType maxy;
    EventDataType miny;

    if (w.zoomY()==0 && PROFILE.appearance->allowYAxisScaling()) {
        maxy=m_physmaxy;
        miny=m_physminy;
        w.roundY(miny,maxy);
    } else {
        maxy=m_maxy;
        miny=m_miny;
        w.roundY(miny,maxy);
    }

    EventDataType yy=maxy-miny;
    EventDataType ymult=float(height-2)/yy;

    barw=(float(width)/float(days));

    float dpr=w.graphView()->devicePixelRatio();

    graph=&w;
    float px=left;
    l_left=w.marginLeft()+gYAxis::Margin;
    l_top=w.marginTop();
    l_width=width;
    l_height=height;
    float py;
    EventDataType total;

    int daynum=0;
    EventDataType h,tmp,tmp2;


    l_offset=(minx) % 86400000L;
    offset=float(l_offset)/86400000.0;

    offset*=barw;
    px=left-offset;
    l_minx=minx;
    l_maxx=maxx+86400000L;

    int total_days=0;
    double total_val=0;
    double total_hours=0;
    bool lastdaygood=false;
    QVector<double> totalcounts;
    QVector<double> totalvalues;
    QVector<float> lastX;
    QVector<short> lastY;
    int numcodes=m_codes.size();
    totalcounts.resize(numcodes);
    totalvalues.resize(numcodes);
    lastX.resize(numcodes);
    lastY.resize(numcodes);
    int zd=minx/86400000L;
    zd--;
    QHash<int,QHash<short,EventDataType> >::iterator d=m_values.find(zd);

    QVector<bool> goodcodes;
    goodcodes.resize(m_goodcodes.size());

    points->setSize(5.0*dpr);
    lastdaygood=true;
    for (int i=0;i<numcodes;i++) {
        totalcounts[i]=0;

        // Set min and max to the opposite largest starting value
        if ((m_type[i]==ST_MIN) || (m_type[i]==ST_SETMIN)) {
            totalvalues[i]=maxy;
        } else if ((m_type[i]==ST_MAX) || (m_type[i]==ST_SETMAX)) {
            totalvalues[i]=miny;
        } else {
            totalvalues[i]=0;
        }
        // Turn off legend display.. It will only display if it's turned back on during draw.
        goodcodes[i]=false;

        if (!m_goodcodes[i]) continue;

        lastX[i]=px;
        if (d!=m_values.end() && d.value().contains(i+1)) {

            tmp=d.value()[i+1];
            h=tmp*ymult;
        } else {
            lastdaygood=false;
            h=0;
        }
        lastY[i]=top+height-1-h;
    }
    float compliance_hours=0;
    if (PROFILE.cpap->showComplianceInfo()) {
        compliance_hours=PROFILE.cpap->complianceHours();
    }

    int incompliant=0;
    Day * day;
    EventDataType hours;

    //quint32 * tptr;
    //EventStoreType * dptr;

    short px2,py2;
    const qint64 ms_per_day=86400000L;
    for (qint64 Q=minx;Q<=maxx+ms_per_day;Q+=ms_per_day) {
        zd=Q/ms_per_day;
        d=m_values.find(zd);

        if (Q<minx)
            goto jumpnext;

        if (d!=m_values.end()) {
            day=m_days[zd];
            if (!m_hours.contains(zd))
                goto jumpnext;

            hours=m_hours[zd];

            int x1=px;
            //x1-=(barw/2.0);
            int x2=px+barw;

            if (x1<left) x1=left;
            if (x2>left+width) x2=left+width;
          //  if (x2<x1)
          //      goto jumpnext;


            if (zd==hl_day) {
                QColor col=QColor("red");
                col.setAlpha(64);
                if (graphtype!=GT_POINTS) {
                    quads->add(x1-1,top,x1-1,top+height,x2,top+height,x2,top,col.rgba());
                } else {
                    quads->add((x1+barw/2)-5,top,(x1+barw/2)-5,top+height,(x2-barw/2)+5,top+height,(x2-barw/2)+5,top,col.rgba());
                }
            }

            if (graphtype==GT_SESSIONS) {
                int j;
                QHash<int,QHash<short,EventDataType> >::iterator times=m_times.find(zd);
                QColor col=m_colors[0];
                //if (hours<compliance_hours) col=QColor("#f03030");

                if (zd==hl_day) {
                    col=QColor("gold");
                }
                GLuint col1=col.rgba();
                GLuint col2=brighten(col).rgba();
                //outlines->setColor(Qt::black);

                int np=d.value().size();
                if (np > 0) {
                    for (int i=0;i<goodcodes.size();i++) {
                        goodcodes[i]=true;
                    }
                }
                for (j=0;j < np;j++) {
                    tmp2=times.value()[j]-miny;
                    py=top+height-(tmp2*ymult);

                    tmp=d.value()[j]; // length

                    //tmp-=miny;
                    h=tmp*ymult;

                    quads->add(x1,py,x1,py-h,x2,py-h,x2,py,col1,col2);
                    if (h>0 && barw>2) {
                        outlines->add(x1,py,x1,py-h,x1,py-h,x2,py-h,QColor("black").rgba());
                        outlines->add(x1,py,x2,py,x2,py,x2,py-h,QColor("black").rgba());
                    }
                    totalvalues[0]+=hours*tmp;
                }
                totalcounts[0]+=hours;
                totalvalues[1]+=j;
                totalcounts[1]++;
                total_val+=hours;
                total_hours+=hours;
                total_days++;
            } else {
                if (!d.value().contains(0))
                    goto jumpnext;
                total=d.value()[0];
                //if (total>0) {
                if (day) {
                    EventDataType hours=m_hours[zd];
                    total_val+=total*hours;
                    total_hours+=hours;
                    total_days++;
                }
                py=top+height;

                //}
                bool good;
                SummaryType type;
                for (QHash<short,EventDataType>::iterator g=d.value().begin();g!=d.value().end();g++) {
                    short j=g.key();
                    if (!j) continue;
                    j--;
                    good=m_goodcodes[j];
                    if (!good)
                        continue;

                    type=m_type[j];
                    // code was actually used (to signal the display of the legend summary)
                    goodcodes[j]=good;

                    tmp=g.value();

                    QColor col=m_colors[j];
                    if (type==ST_HOURS) {
                        if (tmp<compliance_hours) {
                            col=QColor("#f04040");
                            incompliant++;
                        }
                    }

                    if (zd==hl_day) {
                        col=QColor("gold");
                    }

                    //if (!tmp) continue;
                    if ((type==ST_MAX) || (type==ST_SETMAX)) {
                        if (totalvalues[j]<tmp)
                            totalvalues[j]=tmp;
                    } else if ((type==ST_MIN) || (type==ST_SETMIN)) {
                        if (totalvalues[j]>tmp)
                            totalvalues[j]=tmp;
                    } else {
                        totalvalues[j]+=tmp*hours;
                    }
                    //if (tmp) {
                        totalcounts[j]+=hours;
                    //}
                    tmp-=miny;
                    h=tmp*ymult; // height in pixels

                    if (graphtype==GT_BAR) {
                        GLuint col1=col.rgba();
                        GLuint col2=brighten(col).rgba();

                        quads->add(x1,py,x1,py-h,col1);
                        quads->add(x2,py-h,x2,py,col2);
                        if (h>0 && barw>2) {
                            outlines->add(x1,py,x1,py-h,x1,py-h,x2,py-h,QColor("black").rgba());
                            outlines->add(x1,py,x2,py,x2,py,x2,py-h,QColor("black").rgba());
                            if (outlines->full()) qDebug() << "WTF??? Outlines full in SummaryChart::paint()";
                        } // if (bar
                        py-=h;
                    } else if (graphtype==GT_LINE) { // if (m_graphtype==GT_BAR
                        GLuint col1=col.rgba();
                        GLuint col2=m_colors[j].rgba();
                        px2=px+barw;
                        py2=(top+height-2)-h;

                        // If more than 1 day between records, skip the vertical crud.
                        if ((px2-lastX[j])>barw+1) {
                            lastdaygood=false;
                        }
                        if (lastdaygood) {
                            if (lastY[j]!=py2) {// vertical line
                                lines->add(lastX[j],lastY[j],px,py2,col2);
                            }
                            lines->add(px-1,py2,px2+1,py2,col1);
                        } else {
                            lines->add(x1-1,py2,x2+1,py2,col1);
                        }
                        lastX[j]=px2;
                        lastY[j]=py2;
                    } else if (graphtype==GT_POINTS) {
                        GLuint col1=col.rgba();
                        GLuint col2=m_colors[j].rgba();
                        px2=px+barw;
                        py2=(top+height-2)-h;

                        // If more than 1 day between records, skip the vertical crud.
                        if ((px2-lastX[j])>barw+1) {
                            lastdaygood=false;
                        }

                        if (zd==hl_day) {
                            points->add(px2-barw/2,py2,col2);
                        }

                        if (lastdaygood) {
                            lines->add(lastX[j]-barw/2,lastY[j],px2-barw/2,py2,col2);
                        } else {
                            lines->add(px+barw/2-1,py2,px+barw/2+1,py2,col1);
                        }
                        lastX[j]=px2;
                        lastY[j]=py2;
                    }
                }  // for(QHash<short
            }
            lastdaygood=true;
        //    if (Q>maxx+extra) break;
        } else {
            if (Q<maxx)
                incompliant++;
            lastdaygood=false;
        }
jumpnext:
        if (px>=left+width+barw)
            break;
        px+=barw;

        daynum++;
        //lastQ=Q;
    }
#if QT_VERSION >= QT_VERSION_CHECK(5,0,0)
    quads->scissor(left*dpr,w.flipY(top+height+2)*dpr,(width)*dpr,(height+1)*dpr);
    lines->scissor(left*dpr,w.flipY(top+height+2)*dpr,(width+1)*dpr,(height+1)*dpr);
    outlines->scissor(left*dpr,w.flipY(top+height+2)*dpr,(width)*dpr,(height+1)*dpr);
#else
    lines->scissor(left,w.flipY(top+height+2),width+1,height+2);
    outlines->scissor(left,w.flipY(top+height+2),width,height+2);
    quads->scissor(left,w.flipY(top+height+2),width,height+2);
#endif
    // Draw Ledgend
    px=left+width-3;
    py=top-5;
    int legendx=px;
    QString a,b;
    int x,y;

    QFontMetrics fm(*defaultfont);
    int bw=fm.width('X');
    int bh=fm.height()/1.8;

    bool ishours=false;
    int good=0;
    for (int j=0;j<m_codes.size();j++) {
        if (!goodcodes[j]) continue;
        good++;
        SummaryType type=m_type[j];
        ChannelID code=m_codes[j];
        EventDataType tval=m_typeval[j];
        switch(type) {
                case ST_WAVG: b="Avg"; break;
                case ST_AVG:  b="Avg"; break;
                case ST_90P:  b="90%"; break;
                case ST_PERC:
                    if (tval>=0.99) b="Max";
                    else if (tval==0.5) b="Med";
                    else b=QString("%1%").arg(tval*100.0,0,'f',0);
                    break;
            //b=QString("%1%").arg(tval*100.0,0,'f',0); break;
                case ST_MIN:  b="Min"; break;
                case ST_MAX:  b="Max"; break;
                case ST_SETMIN:  b="Min"; break;
                case ST_SETMAX:  b="Max"; break;
                case ST_CPH:  b=""; break;
                case ST_SPH:  b="%"; break;
                case ST_HOURS: b=STR_UNIT_Hours; break;
                case ST_SESSIONS: b="Sessions"; break;

                default:
                    b="";
                    break;
        }
        a=schema::channel[code].label();
        if (a==w.title() && !b.isEmpty()) a=b; else a+=" "+b;

        QString val;
        float f=0;
        if (totalcounts[j]>0) {
            if ((type==ST_MIN) || (type==ST_MAX) || (type==ST_SETMIN) || (type==ST_SETMAX)) {
                f=totalvalues[j];
            } else {
                f=totalvalues[j]/totalcounts[j];
            }
        }
        if (type==ST_HOURS) {
            int h=f;
            int m=int(f*60) % 60;
            val.sprintf("%02i:%02i",h,m);
            ishours=true;
        } else {
            val=QString::number(f,'f',2);
        }
        a+="="+val;
        //GetTextExtent(a,x,y);
        //float wt=20*w.printScaleX();
        //px-=wt+x;
        //w.renderText(a,px+wt,py+1);
        //quads->add(px+wt-y/4-y,py-y,px+wt-y/4,py-y,px+wt-y/4,py+1,px+wt-y/4-y,py+1,m_colors[j].rgba());


        //QString text=schema::channel[code].label();

        int wid,hi;
        GetTextExtent(a,wid,hi);
        legendx-=wid;
        w.renderText(a,legendx,top-4);
      //  legendx-=bw/2;

        int tp=top-5-bh/2;
        w.quads()->add(legendx-bw,tp+bh/2,legendx,tp+bh/2,legendx,tp-bh/2,legendx-bw,tp-bh/2,m_colors[j].rgba());
        legendx-=bw*2;


        //lines->add(px,py,px+20,py,m_colors[j]);
        //lines->add(px,py+1,px+20,py+1,m_colors[j]);
    }
    if ((m_graphtype==GT_BAR) && (good>0)) {

        if (m_type.size()>1) {
            float val=total_val/float(total_hours);
            a=m_label+"="+QString::number(val,'f',2)+" ";
            GetTextExtent(a,x,y);
            legendx-=x;
            w.renderText(a,legendx,py+1);
        }
    }

    a="";
    /*if (m_graphtype==GT_BAR) {
        if (m_type.size()>1) {
            float val=total_val/float(total_days);
            a+=m_label+"="+QString::number(val,'f',2)+" ";
            //
        }
    }*/
    a+="Days="+QString::number(total_days,'f',0);
    if (PROFILE.cpap->showComplianceInfo()) {
        if (ishours && incompliant>0) {
            a+=" Low Usage Days="+QString::number(incompliant,'f',0)+" (%"+QString::number((1.0/daynum)*(total_days-incompliant)*100.0,'f',2)+" compliant, defined as >"+QString::number(compliance_hours,'f',1)+" hours)";
        }
    }


    //GetTextExtent(a,x,y);
    //legendx-=30+x;
    //w.renderText(a,px+24,py+5);
    w.renderText(a,left,py+1);
}

QString formatTime(EventDataType v, bool show_seconds=false, bool duration=false,bool show_12hr=false)
{
    int h=int(v);

    if (!duration) {
        h%=24;
    } else show_12hr=false;

    int m=int(v*60) % 60;
    int s=int(v*3600) % 60;

    char pm[3]={"am"};

    if (show_12hr) {
        h>=12 ? pm[0]='p' : pm[0]='a';
        h %= 12;
        if (h==0) h=12;

    } else {
        pm[0]=0;
    }
    if (show_seconds)
        return QString().sprintf("%i:%02i:%02i%s",h,m,s,pm);
    else
        return QString().sprintf("%i:%02i%s",h,m,pm);
}

bool SummaryChart::mouseMoveEvent(QMouseEvent *event,gGraph * graph)
{
    int x=event->x();
    int y=event->y();

    if (!m_rect.contains(x,y)) {
//    if ((x<0 || y<0 || x>l_width || y>l_height)) {
        hl_day=-1;
        //graph->timedRedraw(2000);
        return false;
    }

    x-=m_rect.left();
    y-=m_rect.top();

    double xx=l_maxx-l_minx;

    double xmult=xx/double(l_width+barw);

    qint64 mx=ceil(xmult*double(x-offset));
    mx+=l_minx;
    mx=mx+l_offset;//-86400000L;
    int zd=mx/86400000L;

    Day * day;
    //if (hl_day!=zd)   // This line is an optimization

    {
        hl_day=zd;
        graph->Trigger(2000);

        QHash<int,QHash<short,EventDataType> >::iterator d=m_values.find(hl_day);

        QHash<short,EventDataType> & valhash=d.value();

        x+=m_rect.left(); //gYAxis::Margin+gGraphView::titleWidth; //graph->m_marginleft+
        int y=event->y()-m_rect.top()+rtop-15;
        //QDateTime dt1=QDateTime::fromTime_t(hl_day*86400).toLocalTime();
        QDateTime dt2=QDateTime::fromTime_t(hl_day*86400).toUTC();

        //QTime t1=dt1.time();
        //QTime t2=dt2.time();

        QDate dt=dt2.date();
        if (d!=m_values.end()) {

            day=m_days[zd];

            QString z=dt.toString(Qt::SystemLocaleShortDate);

            // Day * day=m_days[hl_day];
            //EventDataType val;
            QString val;
            if (m_graphtype==GT_SESSIONS) {
                if (m_type[0]==ST_HOURS) {

                    int t=m_hours[zd]*3600.0;
                    int h=t/3600;
                    int m=(t / 60) % 60;
                    //int s=t % 60;
                    val.sprintf("%02i:%02i",h,m);
                } else
                    val=QString::number(d.value()[0],'f',2);
                z+="\r\n"+m_label+"="+val;

                if (m_type[1]==ST_SESSIONS){
                    z+=" (Sess="+QString::number(day->size(),'f',0)+")";
                }

                EventDataType v=m_times[zd][0];
                int lastt=m_times[zd].size()-1;
                if (lastt<0) lastt=0;
                z+="\r\nBedtime="+formatTime(v,false,false,true);
                v=m_times[zd][lastt]+m_values[zd][lastt];
                z+="\r\nWaketime="+formatTime(v,false,false,true);

            } else
            if (m_graphtype==GT_BAR){
                if (m_type[0]==ST_HOURS) {
                    int t=d.value()[0]*3600.0;
                    int h=t/3600;
                    int m=(t / 60) % 60;
                    //int s=t % 60;
                    val.sprintf("%02i:%02i",h,m);
                } else
                    val=QString::number(d.value()[0],'f',2);
                z+="\r\n"+m_label+"="+val;
                //z+="\r\nMode="+QString::number(day->settings_min("FlexSet"),'f',0);

            } else {
                QString a;
                for (int i=0;i<m_type.size();i++) {
                    if (!m_goodcodes[i])
                        continue;
                    if (!valhash.contains(i+1))
                        continue;
                    EventDataType tval=m_typeval[i];
                    switch(m_type[i]) {
                            case ST_WAVG: a="W-avg"; break;
                            case ST_AVG:  a="Avg"; break;
                            case ST_90P:  a="90%"; break;
                            case ST_PERC:
                                if (tval>=0.99) a="Max";
                                else if (tval==0.5) a="Med";
                                else a=QString("%1%").arg(tval*100.0,0,'f',0);
                                break;
                            case ST_MIN:  a="Min"; break;
                            case ST_MAX:  a="Max"; break;
                            case ST_CPH:  a=""; break;
                            case ST_SPH:  a="%"; break;
                            case ST_HOURS: a=STR_UNIT_Hours; break;
                            case ST_SESSIONS: a="Sessions"; break;
                            case ST_SETMIN:  a="Min"; break;
                            case ST_SETMAX:  a="Max"; break;
                            default:
                                a="";
                                break;
                    }
                    if (m_type[i]==ST_SESSIONS) {
                        val=QString::number(d.value()[i+1],'f',0);
                        z+="\r\n"+a+"="+val;
                    } else {
                        //if (day && (day->channelExists(m_codes[i]) || day->settingExists(m_codes[i]))) {
                            schema::Channel & chan=schema::channel[m_codes[i]];
                            EventDataType v;
                            if (valhash.contains(i+1))
                                v=valhash[i+1];
                            else v=0;

                            if (m_codes[i]==Journal_Weight) {
                                val=weightString(v,PROFILE.general->unitSystem());
                            } else {
                                val=QString::number(v,'f',2);
                            }
                            z+="\r\n"+chan.label()+" "+a+"="+val;
                        //}
                    }
                }

            }

            graph->ToolTip(z,x,y-15,p_profile->general->tooltipTimeout());
            return true;
        } else {
            QString z=dt.toString(Qt::SystemLocaleShortDate)+"\r\nNo Data";
            graph->ToolTip(z,x,y-15,p_profile->general->tooltipTimeout());
            return true;
        }
    }


    return false;
}

bool SummaryChart::mousePressEvent(QMouseEvent * event,gGraph * graph)
{
    if (event->modifiers() & Qt::ShiftModifier) {
        //qDebug() << "Jump to daily view?";
        return true;
    }
    Q_UNUSED(graph)
    return false;
}

bool SummaryChart::keyPressEvent(QKeyEvent * event,gGraph * graph)
{
    Q_UNUSED(event)
    Q_UNUSED(graph)
    //qDebug() << "Summarychart Keypress";
    return false;
}

#include "mainwindow.h"
extern MainWindow *mainwin;
bool SummaryChart::mouseReleaseEvent(QMouseEvent * event,gGraph * graph)
{
    if (event->modifiers() & Qt::ShiftModifier) {
        if (hl_day<0) {
            mouseMoveEvent(event,graph);
        }
        if (hl_day>0) {
            QDateTime d=QDateTime::fromTime_t(hl_day*86400).toUTC();
            mainwin->getDaily()->LoadDate(d.date());
            mainwin->JumpDaily();
           //qDebug() << "Jump to daily view?" << d;
            return true;
        }
    }
    Q_UNUSED(event)
    hl_day=-1;
    graph->timedRedraw(2000);
    return false;
}