#include "lrchartitem.h"
#include <QStyleOptionGraphicsItem>
#include <QPainter>

#include "lrdesignelementsfactory.h"
#include "lrchartitemeditor.h"
#include "lrdatasourcemanager.h"
#include "lrpagedesignintf.h"
#include "lrreportengine_p.h"
#include "lrdatadesignintf.h"

namespace{

const QString xmlTag = "ChartItem";

LimeReport::BaseDesignIntf * createChartItem(QObject* owner, LimeReport::BaseDesignIntf*  parent){
    return new LimeReport::ChartItem(owner,parent);
}
bool registred = LimeReport::DesignElementsFactory::instance().registerCreator(
                     xmlTag, LimeReport::ItemAttribs(QObject::tr("Chart Item"),"Item"), createChartItem
                 );
}

namespace LimeReport{

QColor generateColor()
{
    int red = (qrand()%(256 - 1)) + 1;
    int green = (qrand()%(256 - 1)) + 1;
    int blue = (qrand()%(256 - 1)) + 1;;
    return QColor(red,green,blue);
}

QColor color_map[39] = {
        QColor(51,102,204), QColor(220,57,18), QColor(225, 153, 0), QColor(16, 150, 24), QColor(153,0,153),
        QColor(0,153,198), QColor(221, 68, 119),
        QColor(255,0,0), QColor(0,0,139), QColor(0,205,0), QColor(233,30,99), QColor(255,255,0), QColor(244,67,54),
        QColor(156,39,176),  QColor(103,58,183), QColor(63,81,181), QColor(33,153,243),
        QColor(0,150,136), QColor(78,175,80), QColor(139,195,74), QColor(205,228,57),
        QColor(0,139,0), QColor(0,0,255), QColor(255,235,59), QColor(255,193,7),
        QColor(255,152,0), QColor(255,87,34), QColor(121,85,72), QColor(158,158,158),
        QColor(96,125,139), QColor(241,153,185),  QColor(64,64,64),
        QColor(188,229,218), QColor(139,0,0), QColor(139,139,0), QColor(171, 130, 255),
        QColor(139, 123, 139), QColor(255, 0, 255), QColor(139, 69, 19)
};

QString SeriesItem::name() const
{
    return m_name;
}

void SeriesItem::setName(const QString &name)
{
    m_name = name;
}

QString SeriesItem::valuesColumn() const
{
    return m_valuesColumn;
}

void SeriesItem::setValuesColumn(const QString &valuesColumn)
{
    m_valuesColumn = valuesColumn;
}

QString SeriesItem::labelsColumn() const
{
    return m_labelsColumn;
}

void SeriesItem::setLabelsColumn(const QString &labelsColumn)
{
    m_labelsColumn = labelsColumn;
}

SeriesItem *SeriesItem::clone()
{
    SeriesItem* result = new SeriesItem();
    for (int i = 0; i < this->metaObject()->propertyCount(); ++i){
        result->setProperty(this->metaObject()->property(i).name(),property(this->metaObject()->property(i).name()));
    }
    return result;
}

void SeriesItem::fillSeriesData(IDataSource *dataSource)
{
    m_data.clear();

    if (dataSource){
        dataSource->first();
        int currentColorIndex = 0;
        while(!dataSource->eof()){
            if (!m_labelsColumn.isEmpty())
                m_data.labels().append(dataSource->data(m_labelsColumn).toString());
            m_data.values().append(dataSource->data(m_valuesColumn).toDouble());
            m_data.colors().append((currentColorIndex<32)?color_map[currentColorIndex]:generateColor());
            dataSource->next();
            currentColorIndex++;
        }
    }
}

QColor SeriesItem::color() const
{
    return m_color;
}

void SeriesItem::setColor(const QColor &color)
{
    m_color = color;
}

SeriesItem::SeriesItemPreferredType SeriesItem::preferredType() const
{
    return m_preferredType;
}

void SeriesItem::setPreferredType(const SeriesItemPreferredType& type)
{
    m_preferredType = type;
}

ChartItem::ChartItem(QObject *owner, QGraphicsItem *parent)
    : ItemDesignIntf(xmlTag, owner, parent), m_legendBorder(true),
      m_legendAlign(LegendAlignCenter), m_titleAlign(TitleAlignCenter),
      m_chartType(Pie), m_labelsField("")
{
    m_labels<<"First"<<"Second"<<"Thrid";
    m_chart = new PieChart(this);
}

ChartItem::~ChartItem()
{
    foreach (SeriesItem* series, m_series) {
        delete series;
    }
    m_series.clear();
    delete m_chart;
}

ChartItem::TitleAlign ChartItem::titleAlign() const
{
    return m_titleAlign;
}

void ChartItem::setTitleAlign(const TitleAlign &titleAlign)
{
    if (m_titleAlign != titleAlign){
        TitleAlign oldValue = m_titleAlign;
        m_titleAlign = titleAlign;
        notify("titleAlign",oldValue,m_titleAlign);
        update();
    }
}

void ChartItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
    painter->save();
    setupPainter(painter);
    painter->setFont(transformToSceneFont(painter->font()));
    painter->setRenderHint(QPainter::Antialiasing,true);
    painter->setRenderHint(QPainter::TextAntialiasing,true);
    qreal borderMargin = (rect().height()*0.01>10)?(10):(rect().height()*0.01);
    qreal maxTitleHeight = rect().height()*0.2;

    QFont tmpFont = painter->font();

    qreal titleOffset = !m_title.isEmpty()?(((painter->fontMetrics().height()+borderMargin*2)<maxTitleHeight)?
                        (painter->fontMetrics().height()+borderMargin*2):
                        (maxTitleHeight)):0;

    QRectF titleRect = QRectF(borderMargin,borderMargin,rect().width()-borderMargin*2,titleOffset);
    QRectF legendRect = m_chart->calcChartLegendRect(painter->font(), rect(), false, borderMargin, titleOffset);
    QRectF diagramRect = rect().adjusted(borderMargin,titleOffset+borderMargin,
                                         -(legendRect.width()+borderMargin*2),-borderMargin);

    paintChartTitle(painter, titleRect);
    m_chart->paintChartLegend(painter,legendRect);
    m_chart->paintChart(painter,diagramRect);

    painter->restore();
    ItemDesignIntf::paint(painter,option,widget);
}

BaseDesignIntf *ChartItem::createSameTypeItem(QObject *owner, QGraphicsItem *parent)
{
    ChartItem* result = new ChartItem(owner,parent);
    foreach (SeriesItem* series, m_series) {
        result->m_series.append(series->clone());
    }
    return result;
}

QObject *ChartItem::createElement(const QString &collectionName, const QString &elementType)
{
    Q_UNUSED(elementType);
    if (collectionName.compare("series")==0){
        SeriesItem* seriesItem = new SeriesItem();
        m_series.append(seriesItem);
        return seriesItem;
    }
    return 0;
}

int ChartItem::elementsCount(const QString &collectionName)
{
    if (collectionName.compare("series")==0)
        return m_series.count();
    return 0;
}

QObject *ChartItem::elementAt(const QString &collectionName, int index)
{
    if (collectionName.compare("series")==0)
        return m_series.at(index);
    return 0;
}

void ChartItem::updateItemSize(DataSourceManager *dataManager, RenderPass , int )
{
    if (dataManager && dataManager->dataSource(m_datasource)){
        IDataSource* ds =  dataManager->dataSource(m_datasource);
        foreach (SeriesItem* series, m_series) {
            series->setLabelsColumn(m_labelsField);
            series->fillSeriesData(ds);
        }
        fillLabels(ds);
    }
}

void ChartItem::fillLabels(IDataSource *dataSource)
{
    m_labels.clear();
    if (dataSource && !m_labelsField.isEmpty()){
        dataSource->first();
        while(!dataSource->eof()){
            m_labels.append(dataSource->data(m_labelsField).toString());
            dataSource->next();
        }
    }
}

QWidget *ChartItem::defaultEditor()
{
    QSettings* l_settings = (page()->settings() != 0) ?
                                 page()->settings() :
                                 (page()->reportEditor()!=0) ? page()->reportEditor()->settings() : 0;
    QWidget* editor = new ChartItemEditor(this,page(),l_settings);
    editor->setAttribute(Qt::WA_DeleteOnClose);
    return editor;
}

bool ChartItem::isNeedUpdateSize(RenderPass pass) const
{
    return  pass == FirstPass;
}

QList<QString> ChartItem::labels() const
{
    return m_labels;
}

void ChartItem::setLabels(const QList<QString> &labels)
{
    m_labels = labels;
}

QString ChartItem::labelsField() const
{
    return m_labelsField;
}

void ChartItem::setLabelsField(const QString &labelsField)
{
    m_labelsField = labelsField;
}

ChartItem::ChartType ChartItem::chartType() const
{
    return m_chartType;
}

void ChartItem::setChartType(const ChartType &chartType)
{
    if (m_chartType != chartType){
        ChartType oldValue = m_chartType;
        m_chartType = chartType;
        delete m_chart;
        switch (m_chartType) {
        case Pie:
            m_chart = new PieChart(this);
            break;
        case VerticalBar:
            m_chart = new VerticalBarChart(this);
            break;
        case HorizontalBar:
            m_chart = new HorizontalBarChart(this);
            break;
        }
        notify("chartType",oldValue,m_chartType);
        update();
    }
}

QString ChartItem::datasource() const
{
    return m_datasource;
}

void ChartItem::setDatasource(const QString &datasource)
{
    m_datasource = datasource;
}

void ChartItem::paintChartTitle(QPainter *painter, QRectF titleRect)
{
    painter->save();
    QFont tmpFont = painter->font();
    QFontMetrics fm(tmpFont);
    while ((fm.height()>titleRect.height() || fm.width(m_title)>titleRect.width())
           && tmpFont.pixelSize()>1) {
        tmpFont.setPixelSize(tmpFont.pixelSize()-1);
        fm = QFontMetrics(tmpFont);
    }
    painter->setFont(tmpFont);
    Qt::AlignmentFlag align = Qt::AlignCenter;
    switch (m_titleAlign) {
    case TitleAlignLeft:
        align = Qt::AlignLeft;
        break;
    case TitleAlignCenter:
        align = Qt::AlignCenter;
        break;
    case TitleAlignRight:
        align = Qt::AlignRight;
        break;
    }
    painter->drawText(titleRect, align, m_title);
    painter->restore();
}


ChartItem::LegendAlign ChartItem::legendAlign() const
{
    return m_legendAlign;
}

void ChartItem::setLegendAlign(const LegendAlign &legendAlign)
{
    if (m_legendAlign != legendAlign){
        LegendAlign oldValue = m_legendAlign;
        m_legendAlign = legendAlign;
        notify("legendAlign",oldValue,m_legendAlign);
        update();
    }
}

bool ChartItem::drawLegendBorder() const
{
    return m_legendBorder;
}

void ChartItem::setDrawLegendBorder(bool legendBorder)
{
    if (m_legendBorder!=legendBorder){
        m_legendBorder = legendBorder;
        notify("legendBorder",!m_legendBorder,m_legendBorder);
        update();
    }
}

QString ChartItem::chartTitle() const
{
    return m_title;
}

void ChartItem::setChartTitle(const QString &title)
{
    if (m_title != title){
        QString oldValue = m_title;
        m_title = title;
        update();
        notify("chartTitle",oldValue,title);
    }
}

QList<SeriesItem *> &ChartItem::series()
{
    return m_series;
}

void ChartItem::setSeries(const QList<SeriesItem *> &series)
{
    m_series = series;
}

bool ChartItem::isSeriesExists(const QString &name)
{
    foreach (SeriesItem* series, m_series) {
        if (series->name().compare(name)==0) return true;
    }
    return false;
}

AbstractChart::AbstractChart(ChartItem *chartItem)
    :m_chartItem(chartItem)
{
    m_designLabels<<QObject::tr("First")<<QObject::tr("Second")<<QObject::tr("Thrid");
}

QRectF AbstractChart::calcChartLegendRect(const QFont &font, const QRectF &parentRect, bool takeAllRect, qreal borderMargin, qreal titleOffset)
{
    QSizeF legendSize = calcChartLegendSize(font);
    qreal legendTopMargin = 0;
    qreal legendBottomMargin = 0;

    switch (m_chartItem->legendAlign()) {
    case ChartItem::LegendAlignTop:
        legendTopMargin = titleOffset+borderMargin;
        legendBottomMargin = parentRect.height()-(legendSize.height()+titleOffset);
        break;
    case ChartItem::LegendAlignCenter:
        legendTopMargin = titleOffset+(parentRect.height()-titleOffset-legendSize.height())/2;
        legendBottomMargin = (parentRect.height()-titleOffset-legendSize.height())/2;
        break;
    case ChartItem::LegendAlignBottom:
            legendTopMargin = parentRect.height()-(legendSize.height()+titleOffset);
            legendBottomMargin = borderMargin;
        break;
    }

    qreal rightOffset = !takeAllRect?((legendSize.width()>parentRect.width()/2-borderMargin)?
                (parentRect.width()/2):
                (parentRect.width()-legendSize.width())):0;

    QRectF legendRect = parentRect.adjusted(
                    rightOffset,
                    (legendSize.height()>(parentRect.height()-titleOffset))?(titleOffset):(legendTopMargin),
                    -borderMargin,
                    (legendSize.height()>(parentRect.height()-titleOffset))?(0):(-legendBottomMargin)
                );

    return legendRect;
}

void AbstractChart::prepareLegendToPaint(QRectF &legendRect, QPainter *painter)
{
    QFont tmpFont = painter->font();
    QSizeF legendSize = calcChartLegendSize(tmpFont);

    if ((legendSize.height()>legendRect.height() || legendSize.width()>legendRect.width())){
        while ( (legendSize.height()>legendRect.height() || legendSize.width()>legendRect.width())
                && tmpFont.pixelSize()>1)
        {
            tmpFont.setPixelSize(tmpFont.pixelSize()-1);
            painter->setFont(tmpFont);
            legendSize = calcChartLegendSize(tmpFont);
        }
        painter->setFont(tmpFont);
        legendRect = calcChartLegendRect(tmpFont, legendRect, true, 0, 0);
    }
}

void PieChart::drawPercent(QPainter *painter, QRectF chartRect, qreal startAngle, qreal angle)
{
    painter->save();

    QPointF center(chartRect.left()+chartRect.width()/2,chartRect.top()+chartRect.height()/2);
    qreal percent = angle/3.6;
#ifdef HAVE_QT4
    qreal radAngle = (angle/2+startAngle)*(M_PI/180);
#endif
#ifdef HAVE_QT5
    qreal radAngle = qDegreesToRadians(angle/2+startAngle);
#endif
    qreal radius = painter->fontMetrics().width("99,9%");
    qreal border = chartRect.height()*0.02;
    qreal length = (chartRect.height())/2-(radius/2+border);
    qreal x,y;
    x = length*qCos(radAngle);
    y = length*qSin(radAngle);
    QPointF endPoint(center.x()+x,center.y()-y);
    painter->setPen(Qt::white);
    QRectF textRect(endPoint.x()-(radius/2),endPoint.y()-(radius/2),radius,radius);

    qreal arcLength = 3.14 * length * angle / 180;
    if (arcLength >= radius)
        painter->drawText(textRect,Qt::AlignCenter,QString::number(percent,'f',1)+"%");
    painter->restore();

}

void PieChart::paintChart(QPainter *painter, QRectF chartRect)
{
    painter->save();
    QPen pen(Qt::white);
    pen.setWidthF(2);
    painter->setPen(pen);

    QBrush brush(Qt::transparent);
    painter->setBrush(brush);
    painter->setBackground(QBrush(Qt::NoBrush));

    QRectF tmpRect = chartRect;
    if (chartRect.height()>chartRect.width()){
        tmpRect.setHeight(chartRect.width());
        tmpRect.adjust(0,(chartRect.bottom()-tmpRect.bottom())/2,
                         0,(chartRect.bottom()-tmpRect.bottom())/2);
    } else {
        tmpRect.setWidth(chartRect.height());
    }

    chartRect = tmpRect;
    painter->drawRect(chartRect);

    if (!m_chartItem->series().isEmpty()&&!m_chartItem->series().at(0)->data()->values().isEmpty()){
        SeriesItem* si = m_chartItem->series().at(0);
        qreal sum = 0;
        foreach(qreal value, si->data()->values()){
            sum+=value;
        }
        qreal onePercent = sum / 100;
        qreal currentDegree = 0;
        for(int i=0; i<si->data()->values().count(); ++i){
            qreal value = si->data()->values().at(i);
            qreal sectorDegree = (value/onePercent)*3.6;
            painter->setBrush(si->data()->colors().at(i));
            painter->drawPie(chartRect,currentDegree*16,sectorDegree*16);
            drawPercent(painter, chartRect, currentDegree, sectorDegree);
            currentDegree += sectorDegree;
        }
    } else {
        painter->setBrush(color_map[0]);
        painter->drawPie(chartRect,0,260*16);
        drawPercent(painter, chartRect, 0, 260);
        painter->setBrush(color_map[1]);
        painter->drawPie(chartRect,260*16,40*16);
        drawPercent(painter, chartRect, 260, 40);
        painter->setBrush(color_map[2]);
        painter->drawPie(chartRect,300*16,60*16);
        drawPercent(painter, chartRect, 300, 60);
    }

    pen.setWidthF(1);
    pen.setColor(Qt::gray);
    painter->setPen(pen);
    painter->setBrush(Qt::NoBrush);
    painter->drawEllipse(chartRect);
    painter->restore();
}

void PieChart::paintChartLegend(QPainter *painter, QRectF legendRect)
{
    prepareLegendToPaint(legendRect, painter);

    int indicatorSize = painter->fontMetrics().height()/2;
    painter->setRenderHint(QPainter::Antialiasing,false);

    if (m_chartItem->drawLegendBorder())
        painter->drawRect(legendRect);

    painter->setRenderHint(QPainter::Antialiasing,true);
    QRectF indicatorsRect = legendRect.adjusted(painter->fontMetrics().height()/2,painter->fontMetrics().height()/2,0,0);

    if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
        qreal cw = 0;
        SeriesItem* si = m_chartItem->series().at(0);
        for (int i=0;i<si->data()->labels().count();++i){
            QString label = si->data()->labels().at(i);
            painter->setPen(Qt::black);
            painter->drawText(indicatorsRect.adjusted(indicatorSize+indicatorSize/2,cw,0,0),label);
            painter->setPen(si->data()->colors().at(i));
            painter->setBrush(si->data()->colors().at(i));
            painter->drawEllipse(
                indicatorsRect.adjusted(
                    0,
                    cw+indicatorSize/2,
                    -(indicatorsRect.width()-indicatorSize),
                    -(indicatorsRect.height()-(cw+indicatorSize+indicatorSize/2))
                )
            );
            cw += painter->fontMetrics().height();
        }
    } else {
        qreal cw = 0;
        for (int i=0;i<m_designLabels.size();++i){
            QString label = m_designLabels.at(i);
            painter->setPen(Qt::black);
            painter->drawText(indicatorsRect.adjusted(indicatorSize+indicatorSize/2,cw,0,0),label);
            painter->setBrush(color_map[i]);
            painter->setPen(color_map[i]);
            painter->drawEllipse(
                indicatorsRect.adjusted(
                    0,
                    cw+indicatorSize/2,
                    -(indicatorsRect.width()-indicatorSize),
                    -(indicatorsRect.height()-(cw+indicatorSize+indicatorSize/2))
                )
            );
            cw += painter->fontMetrics().height();
        }

    }
}

QSizeF PieChart::calcChartLegendSize(const QFont &font)
{
    QFontMetrics fm(font);

    qreal cw = 0;
    qreal maxWidth = 0;

    if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
        SeriesItem* si = m_chartItem->series().at(0);
        foreach(QString label, si->data()->labels()){
            cw += fm.height();
            if (maxWidth<fm.width(label))
                maxWidth = fm.width(label)+10;
        }
    } else {
        foreach(QString label, m_designLabels){
            cw += fm.height();
            if (maxWidth<fm.width(label))
                maxWidth = fm.width(label)+10;
        }
    }
    cw += fm.height();
    return  QSizeF(maxWidth+fm.height()*2,cw);
}

int genNextValue(int value){
    int curValue = value;
    while (curValue%4!=0){
        curValue++;
    }
    return curValue;
}

qreal VerticalBarChart::valuesHMargin(QPainter* painter)
{
    int delta = int(maxValue()-minValue());
    delta = genNextValue(delta);
    return painter->fontMetrics().width(QString::number(delta))+4;
}

qreal VerticalBarChart::valuesVMargin(QPainter *painter)
{
    return painter->fontMetrics().height();
}

QRectF VerticalBarChart::labelsRect(QPainter *painter, QRectF labelsRect)
{
    qreal maxWidth = 0;

    foreach (QString label, m_chartItem->labels()) {
        if (painter->fontMetrics().width(label)>maxWidth)
            maxWidth = painter->fontMetrics().width(label);
    }

    if (maxWidth+vPadding(m_chartItem->rect())> labelsRect.height())
        return labelsRect;
    else
        return labelsRect.adjusted(0,(labelsRect.height()-(maxWidth+vPadding(m_chartItem->rect()))),0,0);
}

void VerticalBarChart::paintChart(QPainter *painter, QRectF chartRect)
{
    QRectF calcRect = labelsRect(painter, chartRect.adjusted(
                                     hPadding(chartRect)*2+valuesHMargin(painter),
                                     chartRect.height()*0.5,
                                     -(hPadding(chartRect)*2),
                                     -vPadding(chartRect)
                                     ));

    qreal barsShift = calcRect.height();
    paintVerticalGrid(painter, chartRect.adjusted(
                  hPadding(chartRect),
                  vPadding(chartRect)+valuesVMargin(painter),
                  -hPadding(chartRect),-(vPadding(chartRect)+barsShift) ));

    paintVerticalBars(painter, chartRect.adjusted(
                  hPadding(chartRect)*2+valuesHMargin(painter),
                  vPadding(chartRect)+valuesVMargin(painter),
                  -(hPadding(chartRect)*2),
                  -(vPadding(chartRect)+barsShift) ));
    paintSerialLines(painter, chartRect.adjusted(
                         hPadding(chartRect)*2+valuesHMargin(painter),
                         vPadding(chartRect)+valuesVMargin(painter),
                         -(hPadding(chartRect)*2),
                         -(vPadding(chartRect)+barsShift) ));
    paintLabels(painter,calcRect);
}


void VerticalBarChart::paintVerticalGrid(QPainter *painter, QRectF gridRect)
{
    int delta = int(maxValue()-minValue());
    delta = genNextValue(delta);

    painter->setRenderHint(QPainter::Antialiasing,false);
    qreal vStep = gridRect.height() / 4;

    for (int i=0;i<5;i++){
        painter->drawText(QRectF(gridRect.bottomLeft()-QPointF(0,vStep*i+painter->fontMetrics().height()),
                                 QSizeF(valuesHMargin(painter),painter->fontMetrics().height())),
                          QString::number(minValue()+i*delta/4));
        painter->drawLine(gridRect.bottomLeft()-QPointF(-valuesHMargin(painter),vStep*i),
                          gridRect.bottomRight()-QPointF(0,vStep*i));
    }

    painter->setRenderHint(QPainter::Antialiasing,true);
}



void VerticalBarChart::paintVerticalBars(QPainter *painter, QRectF barsRect)
{

    int delta = int(maxValue()-minValue());
    delta = genNextValue(delta);

    int barSeriesCount = 0;
    foreach(SeriesItem* series, m_chartItem->series()){
        if (series->preferredType() == SeriesItem::Bar) barSeriesCount++;
    }

    barSeriesCount = (m_chartItem->itemMode()==DesignMode) ? seriesCount() : barSeriesCount;
    if (barSeriesCount < 1) return;
    painter->save();
    painter->setRenderHint(QPainter::Antialiasing,false);

    qreal vStep = barsRect.height() / delta;
    qreal hStep = (barsRect.width() / valuesCount()) / (barSeriesCount == 0 ? 1 : barSeriesCount);
    qreal topShift = (delta - (maxValue()-minValue())) * vStep +barsRect.top();

    if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
        int curSeries = 0;
        foreach (SeriesItem* series, m_chartItem->series()) {
            if (series->preferredType() == SeriesItem::Bar){
                qreal curHOffset = curSeries*hStep+barsRect.left();
                painter->setBrush(series->color());
                foreach (qreal value, series->data()->values()) {
                    painter->drawRect(QRectF(curHOffset, maxValue()*vStep+topShift, hStep, -value*vStep));
                    curHOffset+=hStep*barSeriesCount;
                }
                curSeries++;
            }
        }
    } else {
        qreal curHOffset = barsRect.left();
        int curColor = 0;
        for (int i=0; i<9; ++i){
            if (curColor==3) curColor=0;
            painter->setBrush(color_map[curColor]);
            painter->drawRect(QRectF(curHOffset, maxValue()*vStep+barsRect.top(), hStep, -designValues()[i]*vStep));
            curHOffset+=hStep;
            curColor++;
        }
    }
    painter->restore();
}

void VerticalBarChart::paintSerialLines(QPainter* painter, QRectF barsRect)
{
    painter->save();
    painter->setRenderHint(QPainter::Antialiasing,true);
    int delta = int(maxValue()-minValue());
    delta = genNextValue(delta);

    qreal vStep = barsRect.height() / delta;
    qreal hStep = (barsRect.width() / valuesCount());
    qreal topShift = (delta - (maxValue()-minValue())) * vStep +barsRect.top();

    if (!m_chartItem->series().isEmpty()){
        foreach (SeriesItem* series, m_chartItem->series()) {
            if (series->preferredType() == SeriesItem::Line){
                QPen pen(series->color());
                pen.setWidth(4);
                painter->setPen(pen);
                for (int i = 0; i < series->data()->values().count()-1; ++i ){
                    QPoint startPoint = QPoint((i+1)*hStep + barsRect.left()-hStep/2,
                                               (maxValue()*vStep+topShift) - series->data()->values().at(i)*vStep
                                        );
                    QPoint endPoint = QPoint((i+2)*hStep + barsRect.left()-hStep/2,
                                             (maxValue()*vStep+topShift) - series->data()->values().at(i+1)*vStep
                                      );
                    painter->drawLine(startPoint, endPoint);
                    QRect startPointRect(startPoint,startPoint);
                    QRect endPointRect(endPoint,endPoint);
                    int radius = 4;
                    painter->setBrush(series->color());
                    painter->drawEllipse(startPointRect.adjusted(radius,radius,-radius,-radius));
                    painter->drawEllipse(endPointRect.adjusted(radius,radius,-radius,-radius));

                }
            }
        }
    }
    painter->restore();
}

void VerticalBarChart::paintLabels(QPainter *painter, QRectF labelsRect)
{
    painter->save();
    qreal hStep = (labelsRect.width() / valuesCount());
    bool rotateLabels = false;
    QFontMetrics fm = painter->fontMetrics();
    foreach(QString label, m_chartItem->labels()){
        if (fm.width(label) > hStep){
            rotateLabels = true;
            break;
        }
    }
    if (!m_chartItem->labels().isEmpty()){
        if (rotateLabels){
            painter->rotate(270);
            painter->translate( -(labelsRect.top()+labelsRect.height()), labelsRect.left() );
            foreach (QString label, m_chartItem->labels()) {
                painter->drawText(QRectF(QPoint(0,0),
                                         QSize(labelsRect.height()-4, hStep)), Qt::AlignVCenter | Qt::AlignRight, label);
                painter->translate(0,hStep);
            }
            painter->rotate(-270);
        } else {
            painter->translate( labelsRect.left(), labelsRect.top() );
            foreach (QString label, m_chartItem->labels()) {
                painter->drawText(QRectF(QPoint(0, 4),
                                         QSize(hStep, labelsRect.height()-4)), Qt::AlignHCenter | Qt::AlignTop, label);
                painter->translate(hStep, 0);
            }
        }
    }
    painter->restore();
}

AbstractSeriesChart::AbstractSeriesChart(ChartItem *chartItem)
    :AbstractChart(chartItem)
{
    m_designValues[0] = 10;
    m_designValues[1] = 35;
    m_designValues[2] = 15;
    m_designValues[3] = 5;
    m_designValues[4] = 20;
    m_designValues[5] = 10;
    m_designValues[6] = 40;
    m_designValues[7] = 20;
    m_designValues[8] = 5;
}

qreal AbstractSeriesChart::maxValue()
{
    if (m_chartItem->itemMode()==DesignMode) return 40;
    qreal maxValue = 0;
    foreach(SeriesItem* series, m_chartItem->series()){
        foreach(qreal value, series->data()->values()){
            if (value>maxValue) maxValue=value;
        }
    }
    return maxValue;
}

qreal AbstractSeriesChart::minValue()
{
    if (m_chartItem->itemMode()==DesignMode) return 0;
    qreal minValue = 0;
    foreach(SeriesItem* series, m_chartItem->series()){
        foreach(qreal value, series->data()->values()){
            if (value<minValue) minValue=value;
        }
    }
    return minValue;
}

int AbstractSeriesChart::valuesCount()
{
    if (m_chartItem->itemMode()==DesignMode) return 3;
    return (m_chartItem->series().isEmpty())?(0):(m_chartItem->series().at(0)->data()->values().count());
}

int AbstractSeriesChart::seriesCount()
{
    if (m_chartItem->itemMode()==DesignMode) return 3;
    return m_chartItem->series().count();
}

QSizeF AbstractSeriesChart::calcChartLegendSize(const QFont &font)
{
    QFontMetrics fm(font);

    qreal cw = 0;
    qreal maxWidth = 0;

    if (!m_chartItem->series().isEmpty()){
        foreach(SeriesItem* series, m_chartItem->series()){
            cw += fm.height();
            if (maxWidth<fm.width(series->name()))
                maxWidth = fm.width(series->name())+10;
        }
    } else {
        foreach(QString label, m_designLabels){
            cw += fm.height();
            if (maxWidth<fm.width(label))
                maxWidth = fm.width(label)+10;
        }
    }
    cw += fm.height();
    return  QSizeF(maxWidth+fm.height()*2,cw);
}

qreal HorizontalBarChart::valuesHMargin(QPainter *painter)
{
    int delta = int(maxValue()-minValue());
    delta = genNextValue(delta);
    return painter->fontMetrics().width(QString::number(delta))+4;
}

qreal HorizontalBarChart::valuesVMargin(QPainter *painter)
{
    return painter->fontMetrics().height();
}

void HorizontalBarChart::paintChart(QPainter *painter, QRectF chartRect)
{
    QRectF calcRect = labelsRect(painter, chartRect.adjusted(
                                     hPadding(chartRect),
                                     vPadding(chartRect)*2,
                                     -(chartRect.width()*0.5),
                                     -(vPadding(chartRect)*2+valuesVMargin(painter))
                                     ));

    qreal barsShift = calcRect.width();

    paintHorizontalGrid(painter, chartRect.adjusted(
                  hPadding(chartRect)+barsShift,
                  vPadding(chartRect),
                  -(hPadding(chartRect)),-vPadding(chartRect)));
    paintHorizontalBars(painter, chartRect.adjusted(
                  hPadding(chartRect)+barsShift,
                  vPadding(chartRect)*2,
                  -(hPadding(chartRect)),
                  -(vPadding(chartRect)*2) ));

    paintLabels(painter,calcRect);
}

void HorizontalBarChart::paintHorizontalGrid(QPainter *painter, QRectF gridRect)
{
    painter->save();
    int delta = int(maxValue()-minValue());
    delta = genNextValue(delta);

    painter->setRenderHint(QPainter::Antialiasing,false);
    qreal hStep = (gridRect.width()-painter->fontMetrics().width(QString::number(maxValue()))) / 4;

    painter->setFont(adaptValuesFont(hStep-4,painter->font()));

    for (int i=0;i<5;i++){
        painter->drawText(QRectF(gridRect.left()+4+hStep*i,gridRect.bottom()-painter->fontMetrics().height(),
                                 hStep,painter->fontMetrics().height()),
                          QString::number(minValue()+i*delta/4));
        painter->drawLine( gridRect.left()+hStep*i, gridRect.bottom(),
                           gridRect.left()+hStep*i, gridRect.top());

    }
    painter->restore();
}

void HorizontalBarChart::paintHorizontalBars(QPainter *painter, QRectF barsRect)
{
    painter->save();
    painter->setRenderHint(QPainter::Antialiasing,false);
    int delta = int(maxValue()-minValue());
    delta = genNextValue(delta);

    qreal vStep = (barsRect.height()-painter->fontMetrics().height()) / valuesCount() / seriesCount();
    qreal hStep = (barsRect.width()-painter->fontMetrics().width(QString::number(maxValue()))) / delta;

    if (!m_chartItem->series().isEmpty() && !m_chartItem->series().at(0)->data()->labels().isEmpty()){
        int curSeries = 0;
        foreach (SeriesItem* series, m_chartItem->series()) {
            qreal curVOffset = curSeries*vStep+barsRect.top();
            painter->setBrush(series->color());
            foreach (qreal value, series->data()->values()) {
                painter->drawRect(QRectF((-minValue()*hStep)+barsRect.left(), curVOffset, value*hStep, vStep));
                curVOffset+=vStep*seriesCount();
            }
            curSeries++;
        }
    } else {
        qreal curVOffset = barsRect.top();
        int curColor = 0;
        for (int i=0; i<9; ++i){
            if (curColor==3) curColor=0;
            painter->setBrush(color_map[curColor]);
            painter->drawRect(QRectF(barsRect.left(), curVOffset, designValues()[i]*hStep, vStep));
            curVOffset+=vStep;
            curColor++;
        }
    }
    painter->restore();
}

QRectF HorizontalBarChart::labelsRect(QPainter *painter, QRectF labelsRect)
{
    qreal maxWidth = 0;

    foreach (QString label, m_chartItem->labels()) {
        if (painter->fontMetrics().width(label)>maxWidth)
            maxWidth = painter->fontMetrics().width(label);
    }

    if (maxWidth+hPadding(m_chartItem->rect())*2> labelsRect.width())
        return labelsRect;
    else
        return labelsRect.adjusted(0,0,-(labelsRect.width()-(maxWidth+hPadding(m_chartItem->rect())*2)),0);
}

QFont HorizontalBarChart::adaptLabelsFont(QRectF rect, QFont font)
{
    QString maxWord;
    QFontMetrics fm(font);

    foreach(QString label, m_chartItem->labels()){
        foreach (QString currentWord, label.split(QRegExp("\\W+"))){
            if (fm.width(maxWord)<fm.width(currentWord)) maxWord = currentWord;
        }
    }

    qreal curWidth = fm.width(maxWord);
    QFont tmpFont = font;
    while (curWidth>rect.width() && tmpFont.pixelSize()>1){
        tmpFont.setPixelSize(tmpFont.pixelSize()-1);
        QFontMetricsF tmpFM(tmpFont);
        curWidth = tmpFM.width(maxWord);
    }
    return tmpFont;
}

QFont HorizontalBarChart::adaptValuesFont(qreal width, QFont font)
{
    QString strValue = QString::number(maxValue());
    QFont tmpFont = font;
    QScopedPointer<QFontMetricsF> fm(new QFontMetricsF(tmpFont));
    qreal curWidth = fm->width(strValue);
    while (curWidth>width && tmpFont.pixelSize()>1){
        tmpFont.setPixelSize(tmpFont.pixelSize()-1);
        fm.reset(new QFontMetricsF(tmpFont));
        curWidth = fm->width(strValue);
    }
    return tmpFont;
}

void HorizontalBarChart::paintLabels(QPainter *painter, QRectF labelsRect)
{
    painter->save();
    painter->setFont(adaptLabelsFont(labelsRect.adjusted(0,0,-hPadding(m_chartItem->rect()),0),
                               painter->font()));
    qreal vStep = (labelsRect.height() / valuesCount());
    int curLabel = 0;

    painter->translate(labelsRect.topLeft());
    if (!m_chartItem->labels().isEmpty()){
        foreach (QString label, m_chartItem->labels()) {
            painter->drawText(QRectF(QPoint(0,vStep*curLabel),
                                     QSize(labelsRect.width()-hPadding(m_chartItem->rect()),vStep)),
                              Qt::AlignVCenter | Qt::AlignRight | Qt::TextWordWrap,label);

            curLabel++;
        }
    }
    painter->restore();
}

qreal AbstractBarChart::hPadding(QRectF chartRect)
{
    return (chartRect.width()*0.02);
}

qreal AbstractBarChart::vPadding(QRectF chartRect)
{
    return (chartRect.height()*0.02);
}

void AbstractBarChart::paintChartLegend(QPainter *painter, QRectF legendRect)
{
    prepareLegendToPaint(legendRect, painter);
    int indicatorSize = painter->fontMetrics().height()/2;
    painter->setPen(Qt::black);
    painter->setRenderHint(QPainter::Antialiasing,false);
    if (m_chartItem->drawLegendBorder())
        painter->drawRect(legendRect);
    painter->setRenderHint(QPainter::Antialiasing,true);
    QRectF indicatorsRect = legendRect.adjusted(painter->fontMetrics().height()/2,painter->fontMetrics().height()/2,0,0);

    if (!m_chartItem->series().isEmpty()){
        qreal cw = 0;
        foreach(SeriesItem* series, m_chartItem->series()){
            QString label = series->name();
            painter->drawText(indicatorsRect.adjusted(indicatorSize+indicatorSize/2,cw,0,0),label);
            painter->setBrush(series->color());
            painter->drawEllipse(
                indicatorsRect.adjusted(
                    0,
                    cw+indicatorSize/2,
                    -(indicatorsRect.width()-indicatorSize),
                    -(indicatorsRect.height()-(cw+indicatorSize+indicatorSize/2))
                )
            );
            cw += painter->fontMetrics().height();
        }
    } else {
        qreal cw = 0;
        for (int i=0;i<m_designLabels.size();++i){
            QString label = m_designLabels.at(i);
            painter->drawText(indicatorsRect.adjusted(indicatorSize+indicatorSize/2,cw,0,0),label);
            painter->setBrush(color_map[i]);
            painter->drawEllipse(
                indicatorsRect.adjusted(
                    0,
                    cw+indicatorSize/2,
                    -(indicatorsRect.width()-indicatorSize),
                    -(indicatorsRect.height()-(cw+indicatorSize+indicatorSize/2))
                )
            );
            cw += painter->fontMetrics().height();
        }

    }
}

} // namespace LimeReport