/*------------------------------------------------------------------------------
--  This file is a part of the ColorMapChart API
--  Copyright (C) 2016, Plasma Physics Laboratory - CNRS
--
--  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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-------------------------------------------------------------------------------*/
/*--                  Author : Hugo Winter
--                     Mail : hugo.winter@lpp.polytechnique.fr
----------------------------------------------------------------------------*/

#include <private/colormapchart_p.h>
#include <QtCharts/QColorMapSeries>
#include <private/qcolormapseries_p.h>
#include <private/chartpresenter_p.h>
#include <private/abstractdomain_p.h>
#include <private/chartdataset_p.h>
#include <private/qabstractaxis_p.h>
#include <QtGui/QPainter>

#include <QRgb>

#define nbOfColors 65000

QT_CHARTS_BEGIN_NAMESPACE

ColorMapChart::ColorMapChart(QColorMapSeries *series, QGraphicsItem *item)
    : ChartItem(series->d_func(), item),
      m_series(series),
      m_dirty(true),
      m_gradientType(Rainbow),
      m_colorbar(Q_NULLPTR),
      m_isColorBarDrawn(false),
      m_currentClipRect(QRectF())
{
    //    QObject::connect(series, SIGNAL(pointReplaced(int)), this, SLOT(handlePointReplaced(int)));
    //    QObject::connect(series, SIGNAL(pointsReplaced()), this, SLOT(handlePointsReplaced()));
    //    QObject::connect(series, SIGNAL(pointAdded(int)), this, SLOT(handlePointAdded(int)));
    //    QObject::connect(series, SIGNAL(pointRemoved(int)), this, SLOT(handlePointRemoved(int)));
    //    QObject::connect(series, SIGNAL(pointsRemoved(int, int)), this, SLOT(handlePointsRemoved(int, int)));
    //    QObject::connect(this, SIGNAL(clicked(Point3D)), series, SIGNAL(clicked(Point3D)));
    //    QObject::connect(this, SIGNAL(hovered(Point3D,bool)), series, SIGNAL(hovered(Point3D,bool)));
    //    QObject::connect(this, SIGNAL(pressed(Point3D)), series, SIGNAL(pressed(Point3D)));
    //    QObject::connect(this, SIGNAL(released(Point3D)), series, SIGNAL(released(Point3D)));
    //    QObject::connect(this, SIGNAL(doubleClicked(Point3D)), series, SIGNAL(doubleClicked(Point3D)));

    connect(this,SIGNAL(gradientTypeChanged()), this, SLOT(populateColorTable()));

    m_colorTable = new QVector<QRgb>();
    m_colorTable->reserve(nbOfColors);
    populateColorTable();
}

ColorMapChart::~ColorMapChart()
{
    delete m_colorTable;
    delete m_colorbar;
}

void ColorMapChart::setDirty(bool dirty)
{
    m_dirty = dirty;
}

QRectF ColorMapChart::boundingRect() const
{
    return m_rect;
}

void ColorMapChart::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    Q_UNUSED(widget)
    Q_UNUSED(option)

    painter->save();
    //m_series->setUseOpenGL();

    QRectF plotAreaRect = m_series->chart()->plotArea();
    QRectF clipRect = mapColorMapToPlotArea();
    painter->setClipRect(clipRect);

    if(m_currentClipRect !=clipRect)
    {
        m_currentClipRect = clipRect;
        m_grid.reserve(clipRect.width()*clipRect.height());
        m_grid.resize(clipRect.width()*clipRect.height());

        m_series->getUniformGrid(qMax(m_series->minX(),domain()->minX()),qMin(m_series->maxX(),domain()->maxX()),qMax(m_series->minY(),domain()->minY()),qMin(m_series->maxY(),domain()->maxY()), clipRect.width(),clipRect.height(),m_grid, QColorMapSeries::LastPixel);
        addColorBar(plotAreaRect);
    }

    QImage colorMapImage(clipRect.width(),clipRect.height(),QImage::Format_RGB32);
    //http://doc.qt.io/qt-4.8/qimage.html#details :Warning: This will create a QImage with uninitialized data. Call fill() to fill the image with an appropriate pixel value before drawing onto it with QPainter.
    colorMapImage.fill(QColor(Qt::white).rgb());

    fillColorMapImage(colorMapImage);

    painter->drawImage(clipRect,colorMapImage);
    painter->restore();
}

void ColorMapChart::addColorBar(QRectF plotAreaRect)
{
    double maxZ = m_series->maxZ();
    double minZ = m_series->minZ();

    if(m_isColorBarDrawn)
        m_series->chart()->removeAxis(m_colorbar);

    m_colorbar = new QColorBarAxis(plotAreaRect,createColorMapGradient(m_gradientType),minZ, maxZ,this);
    m_series->chart()->addAxis(m_colorbar, Qt::AlignRight);
    m_isColorBarDrawn = true;
}

QRectF ColorMapChart::mapColorMapToPlotArea()
{
    QRectF plotAreaRect = m_series->chart()->plotArea();

    double seriesMinX = m_series->minX();
    double seriesMaxX = m_series->maxX();
    double seriesMinY = m_series->minY();
    double seriesMaxY = m_series->maxY();

    double domainMinX = domain()->minX();
    double domainMaxX = domain()->maxX();
    double domainMinY = domain()->minY();
    double domainMaxY = domain()->maxY();

    double widthToPaint = (qMin(seriesMaxX, domainMaxX)-qMax(seriesMinX, domainMinX))*plotAreaRect.width()/(domainMaxX-domainMinX);
    double heightTopaint= (qMin(seriesMaxY, domainMaxY)-qMax(seriesMinY, domainMinY))*plotAreaRect.height()/(domainMaxY-domainMinY);

    QSizeF size = QSize(widthToPaint,heightTopaint);

    double pointX = (qMax(seriesMinX,domainMinX)-domainMinX)*plotAreaRect.width()/(domainMaxX-domainMinX);
    double pointY = (domainMaxY-qMin(seriesMaxY,domainMaxY))*plotAreaRect.height()/(domainMaxY-domainMinY);

    return QRectF(QPointF(pointX,pointY) ,size);
}

void ColorMapChart::fillColorMapImage(QImage &colorMapImage)
{
    double maxZ = m_series->maxZ();
    double minZ = m_series->minZ();
    double rangeZ = maxZ - minZ;

    int imageWidth = colorMapImage.width();
    int imageHeight = colorMapImage.height();

    for(int i=0;i<imageWidth;i++)
    {
        for(int j=0;j<imageHeight;j++)
        {
            double value = m_grid.at(i+j*(imageWidth));
            double pix=((value-minZ)/rangeZ);
            int indexInColorTable = pix*(nbOfColors-1);
            colorMapImage.setPixel(i,j,m_colorTable->at(indexInColorTable));
        }
    }
}

/*!
    Returns the predefined QLinearGradient corresponding to the \a gradientType passed as argument.
*/
QLinearGradient ColorMapChart::createColorMapGradient(GradientType gradientType)
{
    QLinearGradient gradient(0,0,1,100);
    switch(gradientType)
    {
    case Rainbow :
        gradient.setColorAt(1.0,Qt::darkRed);
        gradient.setColorAt(0.8,Qt::red);
        gradient.setColorAt(0.6,Qt::yellow);
        gradient.setColorAt(0.4,Qt::green);
        gradient.setColorAt(0.2,Qt::cyan);
        gradient.setColorAt(0.0,Qt::blue);
        break;
    case CyclingRainbow :
        gradient.setColorAt(1.0,Qt::red);
        gradient.setColorAt(0.8,Qt::yellow);
        gradient.setColorAt(0.6,Qt::green);
        gradient.setColorAt(0.4,Qt::cyan);
        gradient.setColorAt(0.2,Qt::blue);
        gradient.setColorAt(0.0,Qt::magenta);
        break;
    case BlackAndWhite :
        gradient.setColorAt(1.0, Qt::black);
        gradient.setColorAt(0.0, Qt::white);
        break;
    case ReverseBlackAndWhite :
        gradient.setColorAt(1.0, Qt::white);
        gradient.setColorAt(0.0, Qt::black);
        break;
    default:
        break;
    }
    return gradient;
}

/*!
    Changes the type of gradient used to paint the ColorMap.
*/
void ColorMapChart::changeGradient(GradientType gradientType)
{
    if(m_gradientType == gradientType)
        return;
    else
        m_gradientType = gradientType;
    emit gradientTypeChanged();
}

/*!
    Creates a color table corresponding to the  gradient type currently selected.
*/
void ColorMapChart::populateColorTable()
{
    QLinearGradient gradient = createColorMapGradient(m_gradientType);
    QGradientStops colorStops = gradient.stops();

    for(int i=0;i<nbOfColors;i++)
    {
        double colorIndex = (double)i/nbOfColors;
        for(int k =0;k<colorStops.size()-1;k++)
        {
            QGradientStop lowerBound = colorStops.at(k);
            QGradientStop upperBound = colorStops.at(k+1);
            if(colorIndex >= lowerBound.first && colorIndex < upperBound.first)
            {
                double ratio = (colorIndex-lowerBound.first)/(upperBound.first - lowerBound.first);
                int red      = (int)((1-ratio)*lowerBound.second.red() + ratio*upperBound.second.red());
                int green = (int)((1-ratio)*lowerBound.second.green() + ratio*upperBound.second.green());
                int blue   = (int)((1-ratio)*lowerBound.second.blue() + ratio*upperBound.second.blue());
                m_colorTable->append(qRgb(red, green, blue));
                break;
            }
            else
            {
                if(k==colorStops.size()-2)
                {
                    m_colorTable->append(qRgb(colorStops.at(colorStops.size()-1).second.red(), colorStops.at(colorStops.size()-1).second.green(), colorStops.at(colorStops.size()-1).second.blue()));
                }
            }
        }
    }
}


//handlers

void ColorMapChart::handlePointAdded(int index)
{

}

void ColorMapChart::handlePointRemoved(int index)
{

}

void ColorMapChart::handlePointsRemoved(int index, int count)
{

}

void ColorMapChart::handlePointReplaced(int index)
{

}

void ColorMapChart::handlePointsReplaced()
{

}

void ColorMapChart::handleDomainUpdated()
{

}

bool ColorMapChart::isEmpty()
{

}


#include "moc_colormapchart_p.cpp"

QT_CHARTS_END_NAMESPACE