/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * vim: set ts=8 sts=4 et sw=4 tw=99:
 *
 * gLineOverlayBar 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 "SleepLib/profiles.h"
#include "gLineOverlay.h"

gLineOverlayBar::gLineOverlayBar(ChannelID code, QColor color, QString label, FlagType flt)
    : Layer(code), m_flag_color(color), m_label(label), m_flt(flt)
{
    addVertexBuffer(points = new gVertexBuffer(2048, GL_POINTS));
    points->setSize(4);
    points->setColor(m_flag_color);
    addVertexBuffer(quads = new gVertexBuffer(2048, GL_QUADS));
    //addGLBuf(lines=new GLBuffer(color,1024,GL_LINES));
    points->setAntiAlias(true);
    quads->setAntiAlias(true);
    quads->setColor(m_flag_color);
    //lines->setAntiAlias(true);
}
gLineOverlayBar::~gLineOverlayBar()
{
    //delete lines;
    //delete quads;
    //delete points;
}

void gLineOverlayBar::paint(gGraph &w, int left, int topp, int width, int height)
{
    if (!m_visible) { return; }

    if (!m_day) { return; }

    gVertexBuffer *lines = w.lines();
    int start_py = topp;

    double xx = w.max_x - w.min_x;
    double yy = w.max_y - w.min_y;

    if (xx <= 0) { return; }

    float x1, x2;

    int x, y;

    float bottom = start_py + height - 25 * w.printScaleY(), top = start_py + 25 * w.printScaleY();

    double X;
    double Y;

    bool verts_exceeded = false;

    m_count = 0;
    m_sum = 0;
    m_flag_color = schema::channel[m_code].defaultColor();

    lines->setColor(m_flag_color);
    points->setColor(m_flag_color);

    if (m_flt == FT_Span) {
        m_flag_color.setAlpha(128);
    }

    EventStoreType raw;

    quint32 *tptr;
    EventStoreType *dptr, *eptr;
    qint64 stime;

    OverlayDisplayType odt = PROFILE.appearance->overlayType();
    QHash<ChannelID, QVector<EventList *> >::iterator cei;
    int count;

    qint64 clockdrift = qint64(PROFILE.cpap->clockDrift()) * 1000L;
    qint64 drift = 0;

    // For each session, process it's eventlist
    for (QList<Session *>::iterator s = m_day->begin(); s != m_day->end(); s++) {

        if (!(*s)->enabled()) { continue; }

        cei = (*s)->eventlist.find(m_code);

        if (cei == (*s)->eventlist.end()) { continue; }

        QVector<EventList *> &evlist = cei.value();

        if (evlist.size() == 0) { continue; }

        drift = ((*s)->machine()->GetType() == MT_CPAP) ? clockdrift : 0;

        // Could loop through here, but nowhere uses more than one yet..
        for (int k = 0; k < evlist.size(); k++) {
            EventList &el = *(evlist[k]);
            count = el.count();
            stime = el.first() + drift;
            dptr = el.rawData();
            eptr = dptr + count;
            tptr = el.rawTime();

            ////////////////////////////////////////////////////////////////////////////
            // Skip data previous to minx bounds
            ////////////////////////////////////////////////////////////////////////////
            for (; dptr < eptr; dptr++) {
                X = stime + *tptr;

                if (X >= w.min_x) {
                    break;
                }

                tptr++;
            }

            if (m_flt == FT_Span) {
                ////////////////////////////////////////////////////////////////////////////
                // FT_Span
                ////////////////////////////////////////////////////////////////////////////
                for (; dptr < eptr; dptr++) {
                    X = stime + *tptr++;
                    raw = *dptr;
                    Y = X - (qint64(raw) * 1000.0L); // duration

                    if (Y > w.max_x) {
                        break;
                    }

                    x1 = double(width) / double(xx) * double(X - w.min_x) + left;
                    m_count++;
                    m_sum += raw;
                    x2 = double(width) / double(xx) * double(Y - w.min_x) + left;

                    if (int(x1) == int(x2)) {
                        x2 += 1;
                    }

                    if (x2 < left) {
                        x2 = left;
                    }

                    if (x1 > width + left) {
                        x1 = width + left;
                    }

                    quads->add(x2, start_py,
                               x1, start_py,
                               x1, start_py + height,
                               x2, start_py + height,
                               m_flag_color.rgba());

                    if (quads->full()) {
                        verts_exceeded = true;
                        break;
                    }
                }
            } else if (m_flt == FT_Dot) {
                ////////////////////////////////////////////////////////////////////////////
                // FT_Dot
                ////////////////////////////////////////////////////////////////////////////
                for (; dptr < eptr; dptr++) {
                    X = stime + *tptr++; //el.time(i);
                    raw = *dptr; //el.data(i);

                    if (X > w.max_x) {
                        break;
                    }

                    x1 = double(width) / double(xx) * double(X - w.min_x) + left;
                    m_count++;
                    m_sum += raw;

                    if ((odt == ODT_Bars) || (xx < 3600000)) {
                        // show the fat dots in the middle
                        points->add(x1, double(height) / double(yy)*double(-20 - w.min_y) + topp);

                        if (points->full()) {
                            verts_exceeded = true;
                            break;
                        }
                    } else {
                        // thin lines down the bottom
                        lines->add(x1, start_py + 1, x1, start_py + 1 + 12);

                        if (lines->full()) {
                            verts_exceeded = true;
                            break;
                        }
                    }

                }
            } else if (m_flt == FT_Bar) {
                ////////////////////////////////////////////////////////////////////////////
                // FT_Bar
                ////////////////////////////////////////////////////////////////////////////
                for (; dptr < eptr; dptr++) {
                    X = stime + *tptr++;
                    raw = *dptr;

                    if (X > w.max_x) {
                        break;
                    }

                    x1 = double(width) / double(xx) * double(X - w.min_x) + left;
                    m_count++;
                    m_sum += raw;
                    int z = start_py + height;

                    if ((odt == ODT_Bars) || (xx < 3600000)) {
                        z = top;

                        points->add(x1, top);
                        lines->add(x1, top, x1, bottom);

                        if (points->full()) {
                            verts_exceeded = true;
                            break;
                        }
                    } else {
                        lines->add(x1, z, x1, z - 12);
                    }

                    if (lines->full()) {
                        verts_exceeded = true;
                        break;
                    }

                    if (xx < (1800000)) {
                        GetTextExtent(m_label, x, y);
                        w.renderText(m_label, x1 - (x / 2), top - y + (3 * w.printScaleY()));
                    }
                }
            }

            if (verts_exceeded) {
                break;
            }
        }

        if (verts_exceeded) {
            break;
        }
    }

    if (verts_exceeded) {
        qWarning() << "exceeded maxverts in gLineOverlay::Plot()";
    }
}

gLineOverlaySummary::gLineOverlaySummary(QString text, int x, int y)
    : Layer(CPAP_Obstructive), m_text(text), m_x(x), m_y(y) // The Layer code is a dummy here.
{
}

gLineOverlaySummary::~gLineOverlaySummary()
{
}

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

    if (!m_day) { return; }


    Q_UNUSED(width);
    Q_UNUSED(height);
    float cnt = 0;
    double sum = 0;
    bool isSpan = false;

    for (int i = 0; i < m_overlays.size(); i++) {
        cnt += m_overlays[i]->count();
        sum += m_overlays[i]->sum();

        if (m_overlays[i]->flagtype() == FT_Span) { isSpan = true; }
    }

    double val, first, last;
    double time = 0;

    // Calculate the session time.
    for (QList<Session *>::iterator s = m_day->begin(); s != m_day->end(); s++) {
        if (!(*s)->enabled()) { continue; }

        first = (*s)->first();
        last = (*s)->last();

        if (last < w.min_x) { continue; }

        if (first > w.max_x) { continue; }

        if (first < w.min_x) {
            first = w.min_x;
        }

        if (last > w.max_x) {
            last = w.max_x;
        }

        time += last - first;
    }

    val = 0;

    time /= 1000;
    int h = time / 3600;
    int m = int(time / 60) % 60;
    int s = int(time) % 60;


    time /= 3600;

    //if (time<1) time=1;

    if (time > 0) { val = cnt / time; }



    QString a = QObject::tr("Events") + "=" + QString::number(cnt) + " " + QObject::tr("Duration") +
                " " + QString().sprintf("%02i:%02i:%02i", h, m, s) + ", " + m_text + "=" + QString::number(val,
                        'f', 2);

    if (isSpan) {
        float sph;

        if (!time) { sph = 0; }
        else {
            sph = (100.0 / float(time)) * (sum / 3600.0);

            if (sph > 100) { sph = 100; }
        }

        a += " " + QObject::tr("(\%%1 in events)").arg(sph, 0, 'f',
                2); // eg: %num of time in a span, like Periodic Breathing
    }

    w.renderText(a, left + m_x, top + m_y);
}