#include "qchartglobal.h"
#include "qlegend.h"
#include "qseries.h"
#include "legendmarker_p.h"
#include "legendscrollbutton_p.h"
#include "qxyseries.h"
#include "qlineseries.h"
#include "qareaseries.h"
#include "qscatterseries.h"
#include "qsplineseries.h"
#include "qbarseries.h"
#include "qstackedbarseries.h"
#include "qpercentbarseries.h"
#include "qbarset.h"
#include "qpieseries.h"
#include "qpieslice.h"
#include "chartpresenter_p.h"
#include <QPainter>
#include <QPen>

#include <QGraphicsSceneEvent>

QTCOMMERCIALCHART_BEGIN_NAMESPACE

QLegend::QLegend(QGraphicsItem *parent)
    : QGraphicsObject(parent)
    ,mPos(0,0)
    ,mSize(0,0)
    ,mMinimumSize(50,20)                // TODO: magic numbers
    ,mMaximumSize(150,100)
    ,m_brush(Qt::darkGray)       // TODO: from theme?
    ,mPreferredLayout(QLegend::PreferredLayoutTop)
    ,mFirstMarker(0)
    ,mMargin(5)
{
//    setVisible(false);

    mScrollButtonLeft = new LegendScrollButton(LegendScrollButton::ScrollButtonIdLeft, this);
    mScrollButtonRight = new LegendScrollButton(LegendScrollButton::ScrollButtonIdRight, this);
    mScrollButtonUp = new LegendScrollButton(LegendScrollButton::ScrollButtonIdUp, this);
    mScrollButtonDown = new LegendScrollButton(LegendScrollButton::ScrollButtonIdDown, this);

    connect(mScrollButtonLeft,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
    connect(mScrollButtonRight,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
    connect(mScrollButtonUp,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));
    connect(mScrollButtonDown,SIGNAL(clicked(QGraphicsSceneMouseEvent*)),this,SLOT(handleScrollButtonClicked(QGraphicsSceneMouseEvent*)));

    setZValue(ChartPresenter::LegendZValue);
}

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

    painter->setOpacity(0.8);
    painter->setPen(m_pen);
    painter->setBrush(m_brush);
    painter->drawRect(boundingRect());
}

QRectF QLegend::boundingRect() const
{
    return QRectF(mPos,mSize);
}

void QLegend::setBrush(const QBrush& brush)
{
    if(m_brush!=brush){
        m_brush = brush;
        update();
    }
}

QBrush QLegend::brush() const
{
    return m_brush;
}

void QLegend::setPen(const QPen& pen)
{
    if(m_pen!=pen){
        m_pen = pen;
        update();
    }
}

QPen QLegend::pen() const
{
    return m_pen;
}

void QLegend::setPreferredLayout(QLegend::PreferredLayout preferred)
{
    mPreferredLayout = preferred;
    updateLayout();
}

QLegend::PreferredLayout QLegend::preferredLayout() const
{
    return mPreferredLayout;
}

QSizeF QLegend::maximumSize() const
{
    return mMaximumSize;
}

void QLegend::setMaximumSize(const QSizeF size)
{
    mMaximumSize = size;
    updateLayout();
}

void QLegend::setSize(const QSizeF size)
{
    mSize = size;
    if (mSize.width() > mMaximumSize.width()) {
        mSize.setWidth(mMaximumSize.width());
    }
    if (mSize.height() > mMaximumSize.height()) {
        mSize.setHeight(mMaximumSize.height());
    }
}

void QLegend::setPos(const QPointF &pos)
{
    mPos = pos;
    updateLayout();
}

void QLegend::handleSeriesAdded(QSeries* series, Domain* domain)
{
    Q_UNUSED(domain)

    createMarkers(series);
    connectSeries(series);
    updateLayout();
}

void QLegend::handleSeriesRemoved(QSeries* series)
{
    disconnectSeries(series);

    if (series->type() == QSeries::SeriesTypeArea)
    {
        // This is special case. Area series has upper and lower series, which each have markers
        QAreaSeries* s = static_cast<QAreaSeries*> (series);
        deleteMarkers(s->upperSeries());
        deleteMarkers(s->lowerSeries());
    } else {
        deleteMarkers(series);
    }

    updateLayout();
}

void QLegend::handleAdded(QList<QPieSlice*> slices)
{
    QPieSeries* series = static_cast<QPieSeries*> (sender());
    foreach(QPieSlice* s, slices) {
        LegendMarker* marker = new LegendMarker(series,s,this);
        marker->setName(s->label());
        marker->setBrush(s->sliceBrush());
        connect(marker,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),this,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
        connect(s,SIGNAL(changed()),marker,SLOT(changed()));
        connect(s,SIGNAL(destroyed()),marker,SLOT(deleteLater()));
        connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
        mMarkers.append(marker);
        childItems().append(marker);
    }
    updateLayout();
}

void QLegend::handleRemoved(QList<QPieSlice *> slices)
{
    Q_UNUSED(slices)
    // Propably no need to listen for this, since removed slices are deleted and we listen destroyed signal
//    qDebug() << "QLegend::handleRemoved(QList<QPieSlice*> slices) count:" << slices.count();
}


void QLegend::handleMarkerDestroyed()
{
    // TODO: what if more than one markers are destroyed and we update layout after first one?
    LegendMarker* m = static_cast<LegendMarker*> (sender());
    mMarkers.removeOne(m);
    updateLayout();
}

void QLegend::handleScrollButtonClicked(QGraphicsSceneMouseEvent *event)
{
    Q_UNUSED(event);    // Maybe later somethin happens with right click...

    // TODO: detect sender object. scroll to appropiate direction.
    LegendScrollButton* scrollButton = static_cast<LegendScrollButton*> (sender());
    Q_ASSERT(scrollButton);

    switch (scrollButton->id()) {
    case LegendScrollButton::ScrollButtonIdLeft:
    case LegendScrollButton::ScrollButtonIdUp: {
        // Lower limit is same in these cases
        mFirstMarker--;
        checkMarkerBounds();
        break;
    }
    case LegendScrollButton::ScrollButtonIdRight:
    case LegendScrollButton::ScrollButtonIdDown: {
        mFirstMarker++;
        checkMarkerBounds();
        break;
    }
    default: {
        break;
    }
    }
    updateLayout();
}

void QLegend::connectSeries(QSeries *series)
{
    // Connect relevant signals from series
    switch (series->type())
    {
    case QSeries::SeriesTypeLine: {
//        QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
        break;
    }
    case QSeries::SeriesTypeArea: {
//        QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
        break;
    }
    case QSeries::SeriesTypeBar: {
//        QBarSeries* barSeries = static_cast<QBarSeries*>(series);
        break;
    }
    case QSeries::SeriesTypeStackedBar: {
//        QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
        break;
    }
    case QSeries::SeriesTypePercentBar: {
//        QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
        break;
    }
    case QSeries::SeriesTypeScatter: {
//        QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
        break;
    }
    case QSeries::SeriesTypePie: {
        QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
        connect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleAdded(QList<QPieSlice*>)));
//        connect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleRemoved(QList<QPieSlice*>)));
        break;
    }
    case QSeries::SeriesTypeSpline: {
//        QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
        break;
    }
    default: {
        qDebug()<< "QLegend::connectSeries" << series->type() << "not implemented.";
        break;
    }
    }
}

void QLegend::disconnectSeries(QSeries *series)
{
    // Connect relevant signals from series
    switch (series->type())
    {
    case QSeries::SeriesTypeLine: {
//        QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
        break;
    }
    case QSeries::SeriesTypeArea: {
//        QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
        break;
    }
    case QSeries::SeriesTypeBar: {
//        QBarSeries* barSeries = static_cast<QBarSeries*>(series);
        break;
    }
    case QSeries::SeriesTypeStackedBar: {
//        QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
        break;
    }
    case QSeries::SeriesTypePercentBar: {
//        QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
        break;
    }
    case QSeries::SeriesTypeScatter: {
//        QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
        break;
    }
    case QSeries::SeriesTypePie: {
        QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
        disconnect(pieSeries,SIGNAL(added(QList<QPieSlice*>)),this,SLOT(handleAdded(QList<QPieSlice*>)));
//        disconnect(pieSeries,SIGNAL(removed(QList<QPieSlice*>)),this,SLOT(handleRemoved(QList<QPieSlice*>)));
        break;
    }
    case QSeries::SeriesTypeSpline: {
//        QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
        break;
    }
    default: {
        qDebug()<< "QLegend::disconnectSeries" << series->type() << "not implemented.";
        break;
    }
    }
}

void QLegend::createMarkers(QSeries *series)
{
    switch (series->type())
    {
    case QSeries::SeriesTypeLine: {
        QLineSeries* lineSeries = static_cast<QLineSeries*>(series);
        appendMarkers(lineSeries);
        break;
    }
    case QSeries::SeriesTypeArea: {
        QAreaSeries* areaSeries = static_cast<QAreaSeries*>(series);
        appendMarkers(areaSeries->upperSeries());
        if(areaSeries->lowerSeries())
        appendMarkers(areaSeries->lowerSeries());
        break;
    }

    case QSeries::SeriesTypeBar: {
        QBarSeries* barSeries = static_cast<QBarSeries*>(series);
        appendMarkers(barSeries);
        break;
    }

    case QSeries::SeriesTypeStackedBar: {
        QStackedBarSeries* stackedBarSeries = static_cast<QStackedBarSeries*>(series);
        appendMarkers(stackedBarSeries);
        break;
    }

    case QSeries::SeriesTypePercentBar: {
        QPercentBarSeries* percentBarSeries = static_cast<QPercentBarSeries*>(series);
        appendMarkers(percentBarSeries);
        break;
    }

    case QSeries::SeriesTypeScatter: {
        QScatterSeries *scatterSeries = static_cast<QScatterSeries *>(series);
        appendMarkers(scatterSeries);
        break;
    }

    case QSeries::SeriesTypePie: {
        QPieSeries *pieSeries = static_cast<QPieSeries *>(series);
        appendMarkers(pieSeries);
        break;
    }

    case QSeries::SeriesTypeSpline: {
        QSplineSeries* splineSeries = static_cast<QSplineSeries*>(series);
        appendMarkers(splineSeries);
        break;
    }
    default: {
        qDebug()<< "QLegend::createMarkers" << series->type() << "not implemented.";
        break;
    }
    }
}

void QLegend::appendMarkers(QXYSeries* series)
{
    LegendMarker* marker = new LegendMarker(series,this);
    marker->setName(series->name());
    marker->setBrush(series->brush());
    connect(marker,SIGNAL(clicked(QSeries*,Qt::MouseButton)),this,SIGNAL(clicked(QSeries*,Qt::MouseButton)));
    connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
    mMarkers.append(marker);
    childItems().append(marker);
}

void QLegend::appendMarkers(QBarSeries *series)
{
    foreach(QBarSet* s, series->barSets()) {
        LegendMarker* marker = new LegendMarker(series,s,this);
        marker->setName(s->name());
        marker->setBrush(s->brush());
        connect(marker,SIGNAL(clicked(QBarSet*,Qt::MouseButton)),this,SIGNAL(clicked(QBarSet*,Qt::MouseButton)));
        connect(s,SIGNAL(valueChanged()),marker,SLOT(changed()));
        connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
        mMarkers.append(marker);
        childItems().append(marker);
    }
}

void QLegend::appendMarkers(QPieSeries *series)
{
    foreach(QPieSlice* s, series->slices()) {
        LegendMarker* marker = new LegendMarker(series,s,this);
        marker->setName(s->label());
        marker->setBrush(s->sliceBrush());
        connect(marker,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)),this,SIGNAL(clicked(QPieSlice*,Qt::MouseButton)));
        connect(s,SIGNAL(changed()),marker,SLOT(changed()));
        connect(s,SIGNAL(destroyed()),marker,SLOT(deleteLater()));
        connect(marker,SIGNAL(destroyed()),this,SLOT(handleMarkerDestroyed()));
        mMarkers.append(marker);
        childItems().append(marker);
    }
}

void QLegend::deleteMarkers(QSeries *series)
{
    // Search all markers that belong to given series and delete them.
    foreach (LegendMarker *m, mMarkers) {
        if (m->series() == series) {
            mMarkers.removeOne(m);
            delete m;
        }
    }
}

void QLegend::updateLayout()
{
    // Calculate layout for markers and text
    if (mMarkers.count() <= 0) {
        // Nothing to do
        return;
    }
    checkMarkerBounds();

    // Find out widest item.
    QSizeF markerMaxSize = maximumMarkerSize();

    // Use max height as scroll button size
    rescaleScrollButtons(QSize(markerMaxSize.height() ,markerMaxSize.height()));

    qreal totalWidth = 0;
    qreal totalHeight = 0;
    switch (mPreferredLayout)
    {
    // Both cases organise items horizontally
    case QLegend::PreferredLayoutBottom:
    case QLegend::PreferredLayoutTop: {

        qreal xStep = markerMaxSize.width();
        qreal x = mPos.x() + mMargin;
        qreal y = mPos.y() + mMargin;
        int column = 0;
        int maxColumns = 1;
        qreal scrollButtonPadding = 0;

        // Set correct visibility for scroll scrollbuttons
        if (scrollButtonsVisible()) {
            mScrollButtonLeft->setVisible(true);
            mScrollButtonRight->setVisible(true);
            totalWidth += (mScrollButtonLeft->boundingRect().width() + mMargin) * 2;   // scrollbuttons visible, so add their width to total width
            x += mScrollButtonLeft->boundingRect().width() + mMargin;                  // start position changes by scrollbutton width
            scrollButtonPadding = mScrollButtonLeft->boundingRect().width();
        } else {
            mScrollButtonLeft->setVisible(false);
            mScrollButtonRight->setVisible(false);
        }
        mScrollButtonUp->setVisible(false);
        mScrollButtonDown->setVisible(false);

        for (int i=0; i<mMarkers.count(); i++) {
            LegendMarker* m = mMarkers.at(i);
            if (i<mFirstMarker) {
                // Markers before first are not visible.
                m->setVisible(false);
            } else {
                if ((x + xStep + scrollButtonPadding) > (mPos.x() + mMaximumSize.width())) {
                    // This marker would go outside legend rect.
                    m->setVisible(false);
                } else {
                    // This marker is ok
                    m->setVisible(true);
                    m->setPos(x,y);
                    x += xStep;
                    column++;
                }
            }
            maxColumns = column;
        }

        mScrollButtonLeft->setPos(mPos.x() + mMargin, y);
        mScrollButtonRight->setPos(x+mMargin,y);

        totalWidth += maxColumns * markerMaxSize.width() + mMargin * 2;
        totalHeight = markerMaxSize.height() + mMargin * 2;

        break;
    }
    // Both cases organize items vertically
    case QLegend::PreferredLayoutLeft:
    case QLegend::PreferredLayoutRight: {
        qreal yStep = markerMaxSize.height();
        qreal x = mPos.x() + mMargin;
        qreal y = mPos.y() + mMargin;
        int row = 1;
        int maxRows = 1;
        qreal scrollButtonPadding = 0;

        // Set correct visibility for scroll scrollbuttons
        if (scrollButtonsVisible()) {
            mScrollButtonUp->setVisible(true);
            mScrollButtonDown->setVisible(true);
            totalHeight += (mScrollButtonUp->boundingRect().height() + mMargin) * 2;   // scrollbuttons visible, so add their height to total height
            y += mScrollButtonUp->boundingRect().height() + mMargin;                  // start position changes by scrollbutton height
            scrollButtonPadding = mScrollButtonUp->boundingRect().height();
        } else {
            mScrollButtonUp->setVisible(false);
            mScrollButtonDown->setVisible(false);
        }
        mScrollButtonLeft->setVisible(false);
        mScrollButtonRight->setVisible(false);

        for (int i=0; i<mMarkers.count(); i++) {
            LegendMarker* m = mMarkers.at(i);
            if (i<mFirstMarker) {
                // Markers before first are not visible.
                m->setVisible(false);
            } else {
                if ((y + yStep + scrollButtonPadding) > (mPos.y() + mMaximumSize.height())) {
                    // This marker would go outside legend rect.
                    m->setVisible(false);
                } else {
                    // This marker is ok
                    m->setVisible(true);
                    m->setPos(x,y);
                    y += yStep;
                    row++;
                }
            }
            maxRows = row;
        }

        mScrollButtonUp->setPos(mPos.x() + mMargin, mPos.y() + mMargin);
        mScrollButtonDown->setPos(mPos.x() + mMargin, y + mMargin);

        totalWidth += markerMaxSize.width() + mMargin * 2;
        totalHeight = maxRows * markerMaxSize.height() + mMargin * 4 + scrollButtonPadding; // TODO: check this

        /*
        qreal yStep = markerMaxSize.height();
        qreal x = mPos.x() + mMargin;
        qreal y = mPos.y() + mMargin;
        int row = 0;
        int maxRows = 1;
        int maxColumns = 1;
        for (int i=0; i<mMarkers.count(); i++) {
            LegendMarker* m = mMarkers.at(i);
            if (i<mFirstMarker) {
                // Markers before first are not visible.
                m->setVisible(false);
            } else {
                if ((y + markerMaxSize.height() + mMargin*2) > (mPos.y() + mMaximumSize.height())) {
                    // This marker would go outside legend rect.
                    m->setVisible(false);
                } else {
                    // This marker is ok
                    m->setVisible(true);
                    maxRows = row;
                    m->setPos(x,y);
                    y += yStep;
                    row++;
                }
            }
            maxRows = row;
        }
        totalWidth = maxColumns * markerMaxSize.width() + mMargin * 2;
        totalHeight = maxRows * markerMaxSize.height() + mMargin * 2;
        */
        break;
    }
    default: {
        break;
    }
    }

    mSize.setWidth(totalWidth);
    mSize.setHeight(totalHeight);

    update();
}

void QLegend::rescaleScrollButtons(const QSize &size)
{
    QPolygonF left;
    left << QPointF(size.width(),0) << QPointF(0,size.height()/2) << QPointF(size.width(),size.height());
    QPolygonF right;
    right << QPointF(0,0) << QPointF(size.width(),size.height()/2) << QPointF(0,size.height());
    QPolygonF up;
    up << QPointF(0,size.height()) << QPointF(size.width()/2,0) << QPointF(size.width(),size.height());
    QPolygonF down;
    down << QPointF(0,0) << QPointF(size.width()/2,size.height()) << QPointF(size.width(),0);

    mScrollButtonLeft->setPolygon(left);
    mScrollButtonRight->setPolygon(right);
    mScrollButtonUp->setPolygon(up);
    mScrollButtonDown->setPolygon(down);
}

QSizeF QLegend::maximumMarkerSize()
{
    QSizeF max(0,0);
    foreach (LegendMarker* m, mMarkers) {
        if (m->boundingRect().width() > max.width()) {
            max.setWidth(m->boundingRect().width());
        }
        if (m->boundingRect().height() > max.height()) {
            max.setHeight(m->boundingRect().height());
        }
    }
    return max;
}

void QLegend::checkMarkerBounds()
{
    if ((mPreferredLayout == QLegend::PreferredLayoutLeft) || (mPreferredLayout == QLegend::PreferredLayoutRight)) {
        // Bounds limited by height
        int max;
        if (scrollButtonsVisible()) {
            max = (mMaximumSize.height() - mScrollButtonLeft->boundingRect().height() * 2 - mMargin*2) / maximumMarkerSize().height();
        } else {
            max = mMaximumSize.height() / maximumMarkerSize().height();
        }

        if (mFirstMarker > mMarkers.count() - max) {
            mFirstMarker = mMarkers.count() - max;
        }
    } else {
        // Bounds limited by width
        int max;
        if (scrollButtonsVisible()) {
            max = (mMaximumSize.width() - mScrollButtonLeft->boundingRect().width() * 2 - mMargin*2) / maximumMarkerSize().width();
        } else {
            max = mMaximumSize.width() / maximumMarkerSize().width();
        }

        if (mFirstMarker > mMarkers.count() - max) {
            mFirstMarker = mMarkers.count() - max;
        }
    }

    if (mFirstMarker < 0) {
        mFirstMarker = 0;
    }
}

bool QLegend::scrollButtonsVisible()
{
    // Just a helper to clarify, what the magic below means :)
    if ((mPreferredLayout == QLegend::PreferredLayoutTop) || (mPreferredLayout == QLegend::PreferredLayoutBottom)) {
        return (maximumMarkerSize().width() * mMarkers.count() + mMargin * 3 > mMaximumSize.width());
    }
    return (maximumMarkerSize().height() * mMarkers.count() + mMargin * 3 > mMaximumSize.height());
}

#include "moc_qlegend.cpp"
QTCOMMERCIALCHART_END_NAMESPACE