/*************************************************************************************
 *  Copyright (C) 2011 by Aleix Pol <aleixpol@kde.org>                               *
 *  Copyright (C) 2012-2013 by Percy Camilo T. Aucahuasi <percy.camilo.ta@gmail.com> *
 *                                                                                   *
 *  This program is free software; you can redistribute it and/or                    *
 *  modify it under the terms of the GNU General Public License                      *
 *  as published by the Free Software Foundation; either version 2                   *
 *  of the License, or (at your option) any later version.                           *
 *                                                                                   *
 *  This program is distributed in the hope that it will be useful,                  *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of                   *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                    *
 *  GNU General Public License for more details.                                     *
 *                                                                                   *
 *  You should have received a copy of the GNU General Public License                *
 *  along with this program; if not, write to the Free Software                      *
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA   *
 *************************************************************************************/

#include "plotter2d.h"

#include "planecurve.h"

#include "plotsmodel.h"
#include "private/utils/mathutils.h"

#include <cmath>
#include <QPalette>
#include <QPainter>
#include <qfontdatabase.h>
#include <QDebug>
#include <qnumeric.h>

#if defined(HAVE_IEEEFP_H)
#include <ieeefp.h>
// bool qIsInf(double x) { return !finite(x) && x==x; }
#endif

using namespace Analitza;

// #define DEBUG_GRAPH

class Analitza::Plotter2DPrivate {
public:
    QAbstractItemModel* m_model = nullptr;
    qreal m_dpr = 1.;
};

QColor const Plotter2D::m_axeColor(100,100,255); //TODO convert from const to param/attr and make setAxisColor(Qt::oriantation, qcolor)
QColor const Plotter2D::m_derivativeColor(90,90,160); //TODO remove derivative logic from plotter2d, move it to other module
QString const Plotter2D::PiSymbol(QChar(0x03C0));
QString const Plotter2D::DegreeSymbol(QChar(0x00B0));
QString const Plotter2D::GradianSymbol(QChar(0x1D4D));
double const Plotter2D::Pi6 = M_PI_2/3.0;
double const Plotter2D::Pi12 = Plotter2D::Pi6*0.5;
double const Plotter2D::Pi36 = Plotter2D::Pi6/6.0;
const double Plotter2D::ZoomInFactor = 0.97/2; // (regular mouse wheel forward value) / 2
const double Plotter2D::ZoomOutFactor = 2*1.03; // 2 x (regular mouse wheel backward value)

struct Plotter2D::GridInfo
{
    double inc, xini, yini, xend, yend;
    int incLabelSkip;
    // sub5 flag is used for draw sub 5 intervals instead of 4
    int subinc; // true if inc=5*pow(10,n) (so, in this case, we draw 5 sub intervals, not 4)
    // we need scale for ticks, and for labels, thicks can be minor, labels no: so 
    // this is necessary for minor ticks and for minir grid (but not for labels, so when draw labels we need )
    int nxiniticks, nyiniticks, nxendticks, nyendticks; // nxini = floor(viewport.left()/inc), so xini is nxini*inc ... and so on
    int nxinilabels, nyinilabels, nxendlabels, nyendlabels; // nxini = floor(viewport.left()/inc), so xini is nxini*inc ... and so on
};

Plotter2D::Plotter2D(const QSizeF& size)
    : m_showGrid(true)
    , m_showMinorGrid(false)
    , m_gridColor(QColor(Qt::lightGray).lighter(120))
    , m_backgroundColor(Qt::white)
    , m_autoGridStyle(true)
    , m_gridStyleHint(Squares)
    , rang_x(0)
    , rang_y(0)
    , m_keepRatio(true)
    , m_dirty(true)
    , m_size(size)
    , d(new Plotter2DPrivate)
    , m_angleMode(Radian)
    , m_scaleMode(Linear)
    , m_showTicks(Qt::Vertical|Qt::Horizontal)
    , m_showTickLabels(Qt::Vertical|Qt::Horizontal)
    , m_showMinorTicks(false)
    , m_showAxes(Qt::Vertical|Qt::Horizontal)
    , m_showPolarAxis(false)
    , m_showPolarAngles(false)
    , m_axisXLabel(QStringLiteral("x"))
    , m_axisYLabel(QStringLiteral("y"))
{}

Plotter2D::~Plotter2D()
{
    delete d;
}

void Plotter2D::setGridStyleHint(GridStyle suggestedgs)
{
    m_gridStyleHint = suggestedgs;
    
    forceRepaint();
}

const QColor Plotter2D::computeSubGridColor() const
{
    //impl. details: since any kde user can create any palette style, we need this hard/magic numbres
    // because there is no way to guess, however, this code covers almost any case, 
    // it was tested with more then 35 color styles, and all give good results.
    
    QColor col = m_gridColor;
    
    if (m_backgroundColor.value() < 200)
    {
        if (m_gridColor.value() < 40)
            col.setHsv(col.hsvHue(), col.hsvSaturation(), m_gridColor.value()-15);
        else
            col.setHsv(col.hsvHue(), col.hsvSaturation(), m_gridColor.value()>=255?120:m_gridColor.value()-10);
    }
    else // e.g: background color white and grid color black
        if (m_backgroundColor.value() < 245)
            col.setHsv(col.hsvHue(), col.hsvSaturation(), m_backgroundColor.value()-(m_backgroundColor.value()-200)/3);
        else
            col.setHsv(col.hsvHue(), col.hsvSaturation(), m_backgroundColor.value()-(m_backgroundColor.value()-200)/8);            
    
    return col;
}

const Plotter2D::GridInfo Plotter2D::getGridInfo() const
{
    GridInfo ret;
    
    if (m_scaleMode == Linear) {
        const double val = log10(qMax(viewport.width(), -viewport.height()));
        const double diff = val-floor(val);
        const double magnitude = pow(10, floor(val)-1);

        ret.inc = magnitude;
        ret.incLabelSkip = diff < 0.5 ? 1 : 3;
    } else {
        ret.inc = M_PI;
        ret.incLabelSkip = 1;
    }

    ret.subinc = 4;
    
    ret.nxinilabels = std::floor(viewport.left()/ret.inc);
    ret.nyinilabels = std::floor(viewport.bottom()/ret.inc);
    ret.nxendlabels = std::ceil(viewport.right()/ret.inc);
    ret.nyendlabels = std::ceil(viewport.top()/ret.inc);
    
    ret.xini = ret.nxinilabels*ret.inc;
    ret.yini = ret.nyinilabels*ret.inc;
    ret.xend = ret.nxendlabels*ret.inc;
    ret.yend = ret.nyendlabels*ret.inc;

    const bool drawminor = m_showMinorGrid || m_showMinorTicks;
    const double nfactor = drawminor ? ret.subinc : 1;
    
    ret.nxiniticks = nfactor*ret.nxinilabels;
    ret.nyiniticks = nfactor*ret.nyinilabels;
    ret.nxendticks = nfactor*ret.nxendlabels;
    ret.nyendticks = nfactor*ret.nyendlabels;
    
    return ret; 
}

void Plotter2D::drawGrid(QPaintDevice *qpd)
{
    QPainter p;
    p.begin(qpd);
    
    int current=currentFunction();
    PlotItem* plot = itemAt(current);
    
    GridStyle t = Squares; // default for Cartesian coord. sys.
    
    if (plot && plot->coordinateSystem() == Polar)
        t = Circles;
    
    if (!m_autoGridStyle)
        t = m_gridStyleHint;
    
    drawAxes(&p, t);
}

void Plotter2D::drawAxes(QPainter* painter, GridStyle gridStyle) const
{
    GridInfo grid = getGridInfo();
    
    switch (gridStyle) 
    {
        case Circles: drawCircles(painter, grid, gridStyle); break;
        default: drawSquares(painter, grid, gridStyle); break;
    }
    
    drawMainAxes(painter);
    //NOTE always draw the ticks at the end: avoid the grid lines overlap the ticks text
    drawGridTickLabels(painter, grid, gridStyle);
}

void Plotter2D::drawMainAxes(QPainter* painter) const
{
    const QFontMetrics fm(painter->font());
    const QPen axesPen(m_axeColor, 1, Qt::SolidLine);
    const QPointF center = toWidget(QPointF(0.,0.));
    
    painter->setPen(axesPen);
    painter->setBrush(axesPen.color());
    
    const int startAngleX = 150*16;
    const int startAngleY = 240*16;
    const int spanAngle = 60*16;
    const QPointF Xright(this->width(), center.y());
    const QPointF Ytop(center.x(), 0.);
    const double arrowWidth=15., arrowHeight=4.;
    const QPointF dpx(arrowWidth, arrowHeight);
    const QPointF dpy(arrowHeight, arrowWidth);
    const QRectF rectX(Xright+dpx, Xright-dpx);
    const QRectF rectY(Ytop+dpy, Ytop-dpy);

    if (m_showAxes&Qt::Horizontal)
    {
        painter->drawLine(QPointF(0., center.y()), Xright);
        
        painter->setRenderHint(QPainter::Antialiasing, true);
        painter->drawPie(rectX, startAngleX, spanAngle);
    }

    if (m_showAxes&Qt::Vertical)
    {
        painter->drawLine(Ytop, QPointF(center.x(), this->height()));
        
        painter->setRenderHint(QPainter::Antialiasing, true);
        painter->drawPie(rectY, startAngleY, spanAngle);
    }

    painter->setRenderHint(QPainter::Antialiasing, true);
    // axis labels
    QFont labelsfont = painter->font();
    labelsfont.setBold(true);

    painter->drawText(Xright.x() - fm.width(m_axisXLabel) - 5, center.y() - 20, m_axisXLabel);
    painter->drawText(center.x() + 5, Ytop.y() + fm.height() + 15, m_axisYLabel);

    //write coords
    QString rightBound=QString::number(viewport.right());
    int width=painter->fontMetrics().width(rightBound);

    painter->drawText(QPointF(3.+this->width()/2., 13.                 ), QString::number(viewport.top()));
    painter->drawText(QPointF(3.+this->width()/2., this->height()-5.   ), QString::number(viewport.bottom()));
    painter->drawText(QPointF(8.                 , this->height()/2.-5.), QString::number(viewport.left()));
    painter->drawText(QPointF(this->width()-width, this->height()/2.-5.), rightBound);
    //EO write coords
}

const QString Plotter2D::computeAngleLabelByFrac(unsigned int n, unsigned int d) const
{
    QString s;
    
    switch (m_angleMode)
    {
        case Radian:
        {
            s = (n==1) ? QString() : QString::number(n);
            s += PiSymbol;
            s += (d==1) ? QString() : '/'+QString::number(d);
        }
        break;
        case Degree: s = QString::number(radiansToDegrees(n*M_PI/d))+DegreeSymbol; break;
        case Gradian:  s = QString::number(radiansToGradians(n*M_PI/d))+GradianSymbol; break;
    }
    
    return s;
}

const QString Plotter2D::computeAngleLabelByStep(unsigned int k, unsigned int step) const
{
    QString s;
    
    switch (m_angleMode)
    {
        case Radian:
        {
            s = (k==1) ? ((step==1) ? QLatin1String("") : QString::number(step)) : QString::number(k*step);
            s += PiSymbol;
        }
        break;
        case Degree: s = QString::number(radiansToDegrees(k*step*M_PI))+DegreeSymbol; break;
        case Gradian:  s = QString::number(radiansToGradians(k*step*M_PI))+GradianSymbol; break;
    }
    
    return s;
}

void Plotter2D::drawCartesianTickLabels(QPainter* painter, const Plotter2D::GridInfo& gridinfo, CartesianAxis axis) const
{
    Q_ASSERT(axis == XAxis || axis == Analitza::YAxis);
    
    const bool isxaxis = (axis == XAxis);
    const double fontHeight = painter->fontMetrics().height();
    
    const bool incbig = (M_PI <= gridinfo.inc);
    const unsigned int bigstep = std::floor(gridinfo.inc/M_PI);
    const unsigned int step = std::ceil(M_PI/gridinfo.inc);
    
    QString s;

    const int from = (axis == Analitza::XAxis) ? gridinfo.nxinilabels : gridinfo.nyinilabels;
    const int to = (axis == Analitza::XAxis) ? gridinfo.nxendlabels : gridinfo.nyendlabels;
    
    painter->save();
    QFont tickFont = QFontDatabase::systemFont(QFontDatabase::SmallestReadableFont);
    painter->setFont(tickFont);
    painter->setPen(QPen(QPalette().text().color()));
    for (int i = from; i <= to; ++i)
    {
        if (i == 0 || i%gridinfo.incLabelSkip!=0) continue;
        
        double newval = i*gridinfo.inc;
        
        const QPointF p = isxaxis
            ? toWidget(QPointF(newval, 0.0))
            : toWidget(QPointF(0.0, newval));
        
        switch (m_scaleMode)
        {
            case Linear: 
                s = QString::number(newval); 
                break;
            case Trigonometric:
            {
                s = (i < 0) ? QString(QLatin1Char('-')) : QString();
                
                if (incbig)
                    s += computeAngleLabelByStep(qAbs(i), bigstep);
                else
                {
                    const QPair<unsigned int, unsigned int> frac = simplifyFraction(qAbs(i), step);
                    
                    s += computeAngleLabelByFrac(frac.first, frac.second);
                }
            }
            break;
        }
        
        const int swidth = painter->fontMetrics().width(s);
        if (isxaxis)
            painter->drawText(p.x() - swidth/2, p.y()+fontHeight, s);
        else
            painter->drawText(p.x() - swidth - fontHeight/2, p.y()+fontHeight/2, s);
    }
    painter->restore();
}

void Plotter2D::drawPolarTickLabels(QPainter* painter, const Plotter2D::GridInfo& gridinfo) const
{
    unsigned int k = 1;

    painter->setPen(m_gridColor);
    
    //TODO if minor
    const double newinc = gridinfo.inc/(gridinfo.subinc); // inc with sub intervals
    
    //x
    // we assume 0 belongs to interval [gridinfo.xini, gridinfo.xend]
    double maxh = qMax(std::abs(gridinfo.xini), std::abs(gridinfo.xend));
    int i = std::ceil(maxh/newinc)/2;
    double x = i*newinc;
    
    if (std::abs(gridinfo.xend) <= std::abs(gridinfo.xini))
        x *= -1.0;
    
    // if 0 doesn't belongs to interval [gridinfo.xini, gridinfo.xend]
    if (((gridinfo.xend < 0.0) && (gridinfo.xini < 0.0)) || 
        ((gridinfo.xend > 0.0) && (gridinfo.xini > 0.0)))
    {
        maxh = gridinfo.xend - gridinfo.xini;
        i = std::ceil(maxh/newinc)/2;
        
        x = gridinfo.xini + i*newinc;
    }
    
    //y
    // we assume 0 belongs to interval [gridinfo.yini, gridinfo.yend]
    maxh = qMax(std::abs(gridinfo.yini), std::abs(gridinfo.yend));
    i = std::ceil(maxh/newinc)/2;
    double y = i*newinc;
    
    if (std::abs(gridinfo.yend) <= std::abs(gridinfo.yini))
        y *= -1.0;
    
    // if 0 doesn't belongs to interval [gridinfo.xini, gridinfo.xend]
    if (((gridinfo.yend < 0.0) && (gridinfo.yini < 0.0)) || 
        ((gridinfo.yend > 0.0) && (gridinfo.yini > 0.0)))
    {
        maxh = gridinfo.yend - gridinfo.yini;
        i = std::ceil(maxh/newinc)/2;
        
        y = gridinfo.yini + i*newinc;
    }
    
    const double r = qMax(std::abs(x), std::abs(y)); // radius
    const unsigned short axisxseparation = 16; // distance between tick text and x-axis 
    const float axispolarseparation = axisxseparation*0.5;
    
    double h = Pi6; // pi/6, then 12 rounds
    double t = 0.0;
    
    unsigned int turns = 12; // 12 turns in [0, 2pi], since h=pi/6
    
    // if we are far from origin then sudivide angles by pi/12
    if (!viewport.contains(QPointF(0.0, 0.0)))
    {
        h = Pi12;
        turns = 24; // 24 turns in [0, 2pi], since h=pi/12
    }
    
    k = 0; 
    
    const unsigned int drawoverxaxiscount = turns/2;
    const unsigned int drawnextyaxiscount = turns/4;
    const unsigned int halfturns = drawoverxaxiscount; // or turns/2;
    
    for (uint j = 0; j < turns; ++j, ++k, t += h) // Pi6 then 24 turns
    {
        const QPair<unsigned int, unsigned int> frac = simplifyFraction(k, halfturns);
        
        QString s = (k != 0) ? computeAngleLabelByFrac(frac.first, frac.second) : QStringLiteral("0");
        QPointF p(r*std::cos(t), r*std::sin(t));
        
        if (viewport.contains(p))
        {

            if (k % drawoverxaxiscount == 0) // draw 0, pi over x
                painter->drawText(toWidget(p)+QPointF(0.0, -axispolarseparation), s);
            else 
                if (k % drawnextyaxiscount == 0) // draw pi/2, 3pi/2 next to y
                    painter->drawText(toWidget(p)+QPointF(axispolarseparation, 0.0), s);
                else
                    painter->drawText(toWidget(p), s);
        }
    }
}

void Plotter2D::drawGridTickLabels(QPainter* painter, const GridInfo& gridinfo, GridStyle gridStyle) const
{
    if (m_showTickLabels & Qt::Horizontal)
        drawCartesianTickLabels(painter, gridinfo, XAxis);
    
    if (m_showTickLabels & Qt::Vertical)
        drawCartesianTickLabels(painter, gridinfo, YAxis);
    
    if ((gridStyle == Circles) && m_showPolarAngles && m_showGrid) // draw labels for angles (polar axis)
        drawPolarTickLabels(painter, gridinfo);
}

void Plotter2D::drawCircles(QPainter* painter, const GridInfo& gridinfo, GridStyle gridStyle) const
{
    Q_ASSERT(gridStyle == Analitza::Circles);
    painter->setRenderHint(QPainter::Antialiasing, false);
    
    const QPen textPen = QPen(QPalette().text().color());
    const QPen gridPen(m_gridColor);
    const QPen subGridPen(computeSubGridColor());

    const unsigned short nsubinc = gridinfo.subinc; // count for draw sub intervals
    const bool drawminor = m_showMinorGrid || m_showMinorTicks;
    const double inc = drawminor ? gridinfo.inc/nsubinc : gridinfo.inc; // if show minor, then inc with sub intervals
    
    if (m_showGrid) 
    {
        const qreal until = qMax(qMax(qAbs(viewport.left()), qAbs(viewport.right())), qMax(qAbs(viewport.top()), qAbs(viewport.bottom())))*M_SQRT2;
        
        int k = 1;
        
        painter->setPen(gridPen);
        
        for (double i = inc; i < until; i += inc, ++k)
        {
            if (i == 0.0) continue;
            
            QPointF p(toWidget(QPointF(i,i)));
            QPointF p2(toWidget(QPointF(-i,-i)));
            QRectF er(p.x(),p.y(), p2.x()-p.x(), p2.y()-p.y());
            
            if ((k % nsubinc == 0) || !drawminor) // intervals
            {
                painter->setPen(gridPen);
                painter->drawEllipse(er);
            }
            else if (m_showMinorGrid)// sub intervals
            {
                painter->setPen(subGridPen);
                painter->drawEllipse(er);
            }
        }
        
        if (m_showPolarAxis) // draw polar rays
        {
            double h = Pi12; // 2pi/(Pi/12) = 24 steps/turns
            const double r = std::abs(until); // radius
            const QPointF origin = toWidget(QPointF(0,0));
            
            int k = 1;
            unsigned int alternatesubgridcount = 2;
            unsigned int dontdrawataxiscount = 5;
            unsigned int steps = 24; // or turns
            
            // if we are far from origin then sudivide angles by 5 degrees
            if (!viewport.contains(QPointF(0.0, 0.0)))
            {
                h = Pi36; // 2pi/(Pi/36) = 72 steps
                steps = 72; // or turns
                alternatesubgridcount = 3;
                dontdrawataxiscount = 17;
            }
            
            double t = h;
            for (uint j = 1; j <= steps; ++j, ++k, t += h)
            {
                if (j % alternatesubgridcount == 0)
                    painter->setPen(gridPen);
                else if (m_showMinorGrid)
                {
                    painter->setPen(subGridPen);

                    QPointF p = toWidget(QPointF(r*std::cos(t), r*std::sin(t)));
                    painter->drawLine(origin, p);

                    if (k % dontdrawataxiscount == 0) // avoid draw the ray at 0,pi/2,pi,3pi/2
                    {
                        t += h;
                        ++j;
                    }
                }
            }
        }
    }
    
    //BEGIN draw ticks
    if (m_showTickLabels & Qt::Horizontal)
    {
        painter->setPen(textPen);
        const QPointF yoffset(0.,-3.);
        
        for (int j = gridinfo.nxiniticks, i = 0; j < gridinfo.nxendticks; ++j, ++i)
        {
            if (j == 0) continue;
            
            const double x = j*inc;
            const QPointF p = toWidget(QPointF(x, 0.));

            if ((i % nsubinc == 0) || !drawminor || m_showMinorTicks)
                painter->drawLine(p, p+yoffset);
        }
    }
    
    if (m_showTickLabels & Qt::Vertical)
    {
        painter->setPen(textPen);
        const QPointF xoffset(3.,0.);
        
        for (int j = gridinfo.nyiniticks, i = 0; j < gridinfo.nyendticks; ++j, ++i)
        {
            if (j == 0) continue;
            
            const double y = j*inc;
            
            const QPointF p = toWidget(QPointF(0., y));
            
            if ((i % nsubinc == 0) || !(m_showMinorGrid || m_showMinorTicks) || m_showMinorTicks)
                painter->drawLine(p, p+xoffset);
        }
    }
    //END draw ticks
}

void Plotter2D::drawSquares(QPainter* painter, const GridInfo& gridinfo, GridStyle gridStyle) const
{
    painter->setRenderHint(QPainter::Antialiasing, false);
    
    const QPen gridPen(m_gridColor);
    const QPen subGridPen(computeSubGridColor());
    const QPen gridPenBold(gridPen.brush(), 2);
    const QPen subGridPenBold(subGridPen.brush(), gridPenBold.widthF());
    
    const unsigned short nsubinc = gridinfo.subinc; // count for draw sub intervals
    const bool drawminor = m_showMinorGrid || m_showMinorTicks;
    const double inc = drawminor? gridinfo.inc/nsubinc : gridinfo.inc; // if show minor, then inc with sub intervals
    
    for (int n = gridinfo.nxiniticks, i = 0; n < gridinfo.nxendticks; ++n, ++i)
    {
        if (n == 0) continue;
        
        const double x = n*inc;
        const QPointF p = toWidget(QPointF(x, 0.));
        
        if (m_showGrid && gridStyle == Crosses)
        {
            const double crossside = 5;
            const double centx = p.x();

            for (int j = gridinfo.nyiniticks, k = 0; j < gridinfo.nyendticks; ++j, ++k)
            {
                if (j == 0) continue;

                const double y = j*inc;
                const QPointF py = toWidget(QPointF(0., y));
                const double centy = py.y();
                
                if (((i % nsubinc == 0) && (k % nsubinc == 0)) || !drawminor) // intervals
                {
                    painter->setPen(gridPenBold);
                    painter->drawLine(QPointF(centx-crossside, centy), QPointF(centx+crossside, centy)); // horizontal
                    painter->drawLine(QPointF(centx, centy-crossside), QPointF(centx, centy+crossside)); // vertical
                }
                else if (m_showMinorGrid)// sub intervals
                {
                    painter->setPen(subGridPenBold);
                    painter->drawLine(QPointF(centx-crossside, centy), QPointF(centx+crossside, centy)); // horizontal
                    painter->drawLine(QPointF(centx, centy-crossside), QPointF(centx, centy+crossside)); // vertical
                }
            }
        }
        
        if ((i % nsubinc == 0) || !drawminor) // intervals
        {
            if (m_showGrid && (gridStyle == Squares || gridStyle == VerticalLines))
            {
                painter->setPen(gridPen);
                painter->drawLine(QPointF(p.x(), height()), QPointF(p.x(), 0.));
            }
            
            if ((m_showTicks & Qt::Horizontal))
            {
                painter->setPen(QPen(QPalette().text().color()));
                painter->drawLine(p, p+QPointF(0.,-3.));
            }
        }
        else // sub intervals
        {
            if (m_showGrid && m_showMinorGrid && (gridStyle == Squares || gridStyle == VerticalLines))
            {
                painter->setPen(subGridPen);
                painter->drawLine(QPointF(p.x(), height()), QPointF(p.x(), 0.));
            }
            
            if ((m_showTicks & Qt::Horizontal) && m_showMinorTicks)
            {
                painter->setPen(QPen(QPalette().text().color()));
                painter->drawLine(p, p+QPointF(0.,-3.));
            }
        }
    }
    
    for (int j = gridinfo.nyiniticks, i = 0; j < gridinfo.nyendticks; ++j, ++i)
    {
        if (j == 0) continue;
        
        const double y = j*inc;
        const QPointF p = toWidget(QPointF(0., y));
        
        if ((i % nsubinc == 0) || !drawminor) // intervals
        {
            if (m_showGrid && (gridStyle == Squares || gridStyle == HorizontalLines))
            {
                painter->setPen(gridPen);
                painter->drawLine(QPointF(0., p.y()), QPointF(width(), p.y()));
            }
            
            if ((m_showTicks & Qt::Horizontal))
            {
                painter->setPen(QPen(QPalette().text().color()));
                painter->drawLine(p, p+QPointF(3.,0.));
            }
        }
        else // sub intervals
        {
            if (m_showGrid && m_showMinorGrid && (gridStyle == Squares || gridStyle == HorizontalLines))
            {
                painter->setPen(subGridPen);
                painter->drawLine(QPointF(0., p.y()), QPointF(width(), p.y()));
            }
            
            if ((m_showTicks & Qt::Horizontal) && m_showMinorTicks)
            {
                painter->setPen(QPen(QPalette().text().color()));
                painter->drawLine(p, p+QPointF(3.,0.));
            }
        }
    }
}

PlotItem* Plotter2D::itemAt(int row) const
{
    if (!d->m_model)
        return nullptr;
    
    QModelIndex pi = d->m_model->index(row, 0);

    if (!pi.isValid())
        return nullptr;

    PlotItem* plot = pi.data(PlotsModel::PlotRole).value<PlotItem*>();

    if (plot->spaceDimension() != Dim2D)
        return nullptr;

    return plot;
}

void Plotter2D::drawFunctions(QPaintDevice *qpd)
{
    drawGrid(qpd);
    QPen pfunc(QColor(0,150,0), 2);
    
    QPainter p;
    p.begin(qpd);
    p.setPen(pfunc);

    if (!d->m_model || m_dirty)
        return;
    
    p.setRenderHint(QPainter::Antialiasing, true);
    
    const int current=currentFunction();
    const int dpr = qMax<int>(1, qRound(qpd->logicalDpiX()/100.)) << 1;

    for (int k = 0; k < d->m_model->rowCount(); ++k )
    {
        PlaneCurve* curve = dynamic_cast<PlaneCurve *>(itemAt(k));

        //NOTE from GSOC: not all valid plots always has points (so, we need to check if points().isEmpty() too)
        if (!curve || !curve->isVisible() || curve->points().isEmpty())
            continue;

        pfunc.setColor(curve->color());
        pfunc.setWidth((k==current)+dpr);
        pfunc.setStyle(Qt::SolidLine);
        p.setPen(pfunc);

        const QVector<QPointF> &vect=curve->points();
        QVector<int> jumps=curve->jumps();

        unsigned int pointsCount = vect.count();
        QPointF ultim = toWidget(vect.at(0));

        int nextjump;
        nextjump = jumps.isEmpty() ? -1 : jumps.first();
        if (!jumps.isEmpty()) jumps.remove(0);
// #define DEBUG_GRAPH 1
#ifdef DEBUG_GRAPH
        qDebug() << "---------" << jumps.count()+1;
#endif
        for(unsigned int j=0; j<pointsCount; ++j)
        {
            const QPointF act = toWidget(vect.at(j));

//          qDebug() << "xxxxx" << act << ultim << qIsNaN(act.y()) << qIsNaN(ultim.y());
            if(qIsInf(act.y()) && !qIsNaN(act.y())) qDebug() << "trying to plot from a NaN value" << act << ultim;
            else if(qIsInf(act.y()) && qIsNaN(act.y())) qDebug() << "trying to plot to a NaN value";

            const bool bothinf=(qIsInf(ultim.y()) && qIsInf(act.y())) || (qIsInf(ultim.x()) && qIsInf(act.x()));
            if(!bothinf && !qIsNaN(act.y()) && !qIsNaN(ultim.y()) && nextjump!=int(j)) {
                if(qIsInf(ultim.y())) {
                    if(act.y()<0) ultim.setY(0);
                    if(act.y()>0) ultim.setY(qpd->height());
                }
//
                QPointF act2(act);
                if(qIsInf(act2.y())) {
                    if(ultim.y()<0) act2.setY(0);
                    if(ultim.y()>0) act2.setY(qpd->height());
                }

//              qDebug() << "xxxxx" << act2 << ultim << qIsNaN(act2.y()) << qIsNaN(ultim.y());

                p.drawLine(ultim, act2);

#ifdef DEBUG_GRAPH
                QPen dpen(Qt::red);
                dpen.setWidth(3);
                p.setPen(dpen);
                p.drawPoint(ultim);
                p.setPen(pfunc);
#endif
            } else if(nextjump==int(j)) {
                do {
                    if(nextjump!=int(j))
                        p.drawPoint(act);
                    
                    nextjump = jumps.isEmpty() ? -1 : jumps.first();
                    if (!jumps.isEmpty()) jumps.remove(0);

                } while(!jumps.isEmpty() && jumps.first()==nextjump+1);

#ifdef DEBUG_GRAPH
                qDebug() << "jumpiiiiiing" << ultim << toWidget(vect.at(j));
                QPen dpen(Qt::blue);
                dpen.setWidth(2);
                p.setPen(dpen);
                p.drawLine(QLineF(QPointF(act.x(), height()/2-10), QPointF(act.x(), height()/2+10)));
                p.setPen(pfunc);
#endif
            }

            ultim=act;
        }
    }

    p.end();
}

void Plotter2D::updateFunctions(const QModelIndex & parent, int start, int end)
{
    if (!d->m_model || parent.isValid())
        return;

    QRectF viewportFixed = viewport;
    viewportFixed.setTopLeft(viewport.bottomLeft());
    viewportFixed.setHeight(std::fabs(viewport.height()));
    
    for(int i=start; i<=end; i++)
    {
        PlaneCurve* curve = dynamic_cast<PlaneCurve *>(itemAt(i));

        if (!curve || !curve->isVisible())
            continue;
        
        curve->update(viewportFixed);
    }
    
    m_dirty = false; // m_dirty = false means that the we will not recalculate functions points
    
    forceRepaint();
}

QPair<QPointF, QString> Plotter2D::calcImage(const QPointF& ndp) const
{
    if (!d->m_model || currentFunction() == -1)
        return QPair<QPointF, QString>();

    PlaneCurve* curve = dynamic_cast<PlaneCurve*>(itemAt(currentFunction()));
    
    if (curve && curve->isVisible())
        return curve->image(ndp);

    return QPair<QPointF, QString>();
}

QRectF Plotter2D::normalizeUserViewport(const QRectF uvp)
{
    QRectF normalizeduvp = uvp;
    rang_x = width()/normalizeduvp.width();
    rang_y = height()/normalizeduvp.height();
    
    if (m_keepRatio && rang_x != rang_y)
    {
        rang_y=rang_x=qMin(std::fabs(rang_x), std::fabs(rang_y));

        if(rang_y>0.) rang_y=-rang_y;
        if(rang_x<0.) rang_x=-rang_x;

        double newW=width()/rang_x, newH=height()/rang_x;

        double mx=(uvp.width()-newW)/2.;
        double my=(uvp.height()-newH)/2.;

        normalizeduvp.setLeft(uvp.left()+mx);
        normalizeduvp.setTop(uvp.bottom()-my);
        normalizeduvp.setWidth(newW);
        normalizeduvp.setHeight(-newH); //WARNING why negative distance?

        //Commented because precision could make the program crash
//      Q_ASSERT(uvp.center() == viewport.center());
    }

    return normalizeduvp;
}

void Plotter2D::updateScale(bool repaint)
{
    viewport = normalizeUserViewport(userViewport);

    if (repaint) {
        if (d->m_model && d->m_model->rowCount()>0)
            updateFunctions(QModelIndex(), 0, d->m_model->rowCount()-1);
        else
            forceRepaint();
    }
}

void Plotter2D::setViewport(const QRectF& vp, bool repaint)
{
    userViewport = vp;

    Q_ASSERT(userViewport.top()>userViewport.bottom());
    Q_ASSERT(userViewport.right()>userViewport.left());

    updateScale(repaint);

    viewportChanged();
}

QLineF Plotter2D::slope(const QPointF& dp) const
{
    if (!d->m_model || currentFunction() == -1)
        return QLineF();

    PlaneCurve* plot = dynamic_cast<PlaneCurve*>(itemAt(currentFunction()));
    
    if (plot && plot->isVisible())
    {
        QLineF ret = plot->tangent(dp);
        
        if (ret.isNull() && currentFunction()>=0)
        {
            QPointF a = calcImage(dp-QPointF(.1,.1)).first;
            QPointF b = calcImage(dp+QPointF(.1,.1)).first;

            ret = slopeToLine((a.y()-b.y())/(a.x()-b.x()));
        }
        
        return ret;
    }

    return QLineF();
}

QLineF Plotter2D::toWidget(const QLineF &f) const
{
    return QLineF(toWidget(f.p1()), toWidget(f.p2()));
}

QPointF Plotter2D::toWidget(const QPointF& p) const
{
    double left=-viewport.left(), top=-viewport.top();
    return QPointF((left + p.x()) * rang_x / d->m_dpr,  (top + p.y()) * rang_y / d->m_dpr);
}

QPointF Plotter2D::fromWidget(const QPoint& p) const
{
    double negativePartX = -viewport.left();
    double negativePartY = -viewport.top();
    
    return QPointF(p.x()/(rang_x*d->m_dpr)-negativePartX, p.y()/(rang_y*d->m_dpr)-negativePartY);
}

QPointF Plotter2D::toViewport(const QPoint &mv) const
{
    return QPointF(mv.x()/rang_x, mv.y()/rang_y);
}

void Plotter2D::moveViewport(const QPoint& delta)
{
    QPointF rel = toViewport(delta);
    QRectF viewport = currentViewport();
    
    viewport.moveLeft(viewport.left() - rel.x());
    viewport.moveTop(viewport.top() - rel.y());
    setViewport(viewport);
}

void Plotter2D::scaleViewport(qreal scale, const QPoint& center, bool repaint)
{
    QPointF p = fromWidget(center);
    QSizeF ns = viewport.size()*scale;
    QRectF nv(viewport.topLeft(), ns);
    
    setViewport(nv, false); //NOTE here isn't necessary to repaint, thus false

    QPointF p2 = p-fromWidget(center);
    nv.translate(p2);
    setViewport(nv, repaint);
}

void Plotter2D::setKeepAspectRatio(bool ar)
{
    m_keepRatio=ar;
    updateScale(true);
}

void Plotter2D::setModel(QAbstractItemModel* f)
{
    if(d->m_model == f)
        return;
    
    d->m_model=f;
    modelChanged();
    forceRepaint();
}

void Analitza::Plotter2D::setDevicePixelRatio(qreal dpr)
{
    d->m_dpr = dpr;
}

void Plotter2D::setPaintedSize(const QSize& size)
{
    m_size=size;
    updateScale(true);
}

void Plotter2D::setXAxisLabel(const QString &label)
{
    m_axisXLabel = label;
    forceRepaint();
}

void Plotter2D::setYAxisLabel(const QString &label)
{
    m_axisYLabel = label;
    forceRepaint();
}

void Plotter2D::zoomIn(bool repaint)
{
    scaleViewport(ZoomInFactor, QPoint(m_size.width()*0.5, m_size.height()*0.5), repaint);
}

void Plotter2D::zoomOut(bool repaint)
{
    scaleViewport(ZoomOutFactor, QPoint(m_size.width()*0.5, m_size.height()*0.5), repaint);
}

void Plotter2D::setShowMinorGrid(bool mt)
{
    m_showMinorGrid=mt;
    forceRepaint();
}

void Plotter2D::setShowGrid(bool show)
{
    if (m_showGrid != show) {
        m_showGrid=show;
        forceRepaint();

        showGridChanged();
    }
}

QAbstractItemModel* Plotter2D::model() const
{
    return d->m_model;
}
