/****************************************************************************
**
** Copyright (C) 2012 Digia Plc
** All rights reserved.
** For any questions to Digia, please use contact form at http://qt.digia.com
**
** This file is part of the Qt Commercial Charts Add-on.
**
** $QT_BEGIN_LICENSE$
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.
**
** If you have questions regarding the use of this file, please use
** contact form at http://qt.digia.com
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qxyseries.h"

QTCOMMERCIALCHART_BEGIN_NAMESPACE

/*!
    \class QXYSeries
    \brief The QXYSeries class is a base class for line, spline and scatter series.
*/

/*!
   \fn QPen QXYSeries::pen() const
   \brief  Returns pen used to draw points for series.
    \sa setPen()
*/

/*!
   \fn QBrush QXYSeries::brush() const
   \brief  Returns brush used to draw points for series.
    \sa setBrush()
*/

/*!
    \fn void QXYSeries::clicked(const QPointF& point)
    \brief Signal is emitted when user clicks the \a point on chart.
*/

/*!
    \fn void QXYSeries::pointReplaced(int index)
    \brief \internal \a index
*/

/*!
    \fn void QXYSeries::pointAdded(int index)
    \brief \internal \a index
*/

/*!
    \fn void QXYSeries::pointRemoved(int index)
    \brief \internal \a index
*/

/*!
    \fn void QXYSeries::updated()
    \brief \internal
*/

/*!
    Constructs empty series object which is a child of \a parent.
    When series object is added to QChartView or QChart instance ownerships is transfered.
*/
QXYSeries::QXYSeries(QObject *parent):QSeries(parent)
{
    m_mapX = -1;
    m_mapY = -1;
    m_mapFirst = 0;
    m_mapCount = 0;
    m_mapLimited = false;
    m_mapOrientation = Qt::Vertical;
    //    m_mapYOrientation = Qt::Vertical;
}
/*!
    Destroys the object. Series added to QChartView or QChart instances are owned by those,
    and are deleted when mentioned object are destroyed.
*/
QXYSeries::~QXYSeries()
{
}

/*!
    Adds data point \a x \a y to the series. Points are connected with lines on the chart.
 */
void QXYSeries::append(qreal x,qreal y)
{
    Q_ASSERT(m_x.size() == m_y.size());
    m_x<<x;
    m_y<<y;
    emit pointAdded(m_x.size()-1);
}

/*!
   This is an overloaded function.
   Adds data \a point to the series. Points are connected with lines on the chart.
 */
void QXYSeries::append(const QPointF &point)
{
    append(point.x(),point.y());
}

/*!
   This is an overloaded function.
   Adds list of data \a points to the series. Points are connected with lines on the chart.
 */
void QXYSeries::append(const QList<QPointF> points)
{
    foreach(const QPointF& point , points) {
        append(point.x(),point.y());
    }
}

/*!
  Modifies \a y value for given \a x a value.
*/
void QXYSeries::replace(qreal x,qreal y)
{
    int index = m_x.indexOf(x);
    m_x[index] = x;
    m_y[index] = y;
    emit pointReplaced(index);
}

/*!
  This is an overloaded function.
  Replaces current y value of for given \a point x value with \a point y value.
*/
void QXYSeries::replace(const QPointF &point)
{
    replace(point.x(),point.y());
}

/*!
  Removes first \a x value and related y value.
*/
void QXYSeries::remove(qreal x)
{
    int index = m_x.indexOf(x);

    if (index == -1) return;

    m_x.remove(index);
    m_y.remove(index);

    emit pointRemoved(index);
}

/*!
  Removes current \a x and \a y value.
*/
void QXYSeries::remove(qreal x,qreal y)
{
    int index =-1;
    do {
        index = m_x.indexOf(x,index+1);
    } while (index !=-1 && m_y.at(index)!=y);

    if (index==-1) return;

    m_x.remove(index);
    m_y.remove(index);
    emit pointRemoved(index);
}

/*!
  Removes current \a point x value. Note \a point y value is ignored.
*/
void QXYSeries::remove(const QPointF &point)
{
    remove(point.x(),point.y());
}

/*!
   Removes all data points from the series.
*/
void QXYSeries::removeAll()
{
    m_x.clear();
    m_y.clear();
}

/*!
    \internal \a pos
*/
qreal QXYSeries::x(int pos) const
{
    if (m_model) {
        if (m_mapOrientation == Qt::Vertical)
            // consecutive data is read from model's column
            return m_model->data(m_model->index(pos + m_mapFirst, m_mapX), Qt::DisplayRole).toDouble();
        else
            // consecutive data is read from model's row
            return m_model->data(m_model->index(m_mapX, pos + m_mapFirst), Qt::DisplayRole).toDouble();
    } else {
        // model is not specified, return the data from series' internal data store
        return m_x.at(pos);
    }
}

/*!
    \internal \a pos
*/
qreal QXYSeries::y(int pos) const
{
    if (m_model) {
        if (m_mapOrientation == Qt::Vertical)
            // consecutive data is read from model's column
            return m_model->data(m_model->index(pos + m_mapFirst, m_mapY), Qt::DisplayRole).toDouble();
        else
            // consecutive data is read from model's row
            return m_model->data(m_model->index(m_mapY, pos + m_mapFirst), Qt::DisplayRole).toDouble();
    } else {
        // model is not specified, return the data from series' internal data store
        return m_y.at(pos);
    }
}

/*!
    Returns number of data points within series.
*/
int QXYSeries::count() const
{
    Q_ASSERT(m_x.size() == m_y.size());

    if (m_model) {
        if (m_mapOrientation == Qt::Vertical) {
            // data is in a column. Return the number of mapped items if the model's column have enough items
            // or the number of items that can be mapped
            if (m_mapLimited)
                return qMin(m_mapCount, qMax(m_model->rowCount() - m_mapFirst, 0));
            else
                return qMax(m_model->rowCount() - m_mapFirst, 0);
        } else {
            // data is in a row. Return the number of mapped items if the model's row have enough items
            // or the number of items that can be mapped
            if (m_mapLimited)
                return qMin(m_mapCount, qMax(m_model->columnCount() - m_mapFirst, 0));
            else
                return qMax(m_model->columnCount() - m_mapFirst, 0);
        }
    }

    // model is not specified, return the number of points in the series internal data store
    return m_x.size();
}

/*!
    Returns the data points of the series.
*/
QList<QPointF> QXYSeries::data()
{
    QList<QPointF> data;
    for (int i(0); i < m_x.count() && i < m_y.count(); i++)
        data.append(QPointF(m_x.at(i), m_y.at(i)));
    return data;
}


/*!
    Sets \a pen used for drawing points on the chart. If the pen is not defined, the
    pen from chart theme is used.
    \sa QChart::setChartTheme()
*/
void QXYSeries::setPen(const QPen &pen)
{
    if (pen != m_pen) {
        m_pen = pen;
        emit updated();
    }
}

/*!
    Sets \a brush used for drawing points on the chart. If the brush is not defined, brush
    from chart theme setting is used.
    \sa QChart::setChartTheme()
*/

void QXYSeries::setBrush(const QBrush &brush)
{
    if (brush != m_brush) {
        m_brush = brush;
        emit updated();
    }
}


/*!
    Stream operator for adding a data \a point to the series.
    \sa append()
*/

QXYSeries& QXYSeries::operator<< (const QPointF &point)
{
    append(point);
    return *this;
}


/*!
    Stream operator for adding a list of \a points to the series.
    \sa append()
*/

QXYSeries& QXYSeries::operator<< (const QList<QPointF> points)
{
    append(points);
    return *this;
}


void QXYSeries::modelUpdated(QModelIndex topLeft, QModelIndex bottomRight)
{
    Q_UNUSED(bottomRight)

    if (m_mapOrientation == Qt::Vertical) {
        if (topLeft.row() >= m_mapFirst && (!m_mapLimited || topLeft.row() < m_mapFirst + m_mapCount))
            emit pointReplaced(topLeft.row() - m_mapFirst);
    } else {
        if (topLeft.column() >= m_mapFirst && (!m_mapLimited || topLeft.column() < m_mapFirst + m_mapCount))
            emit pointReplaced(topLeft.column() - m_mapFirst);
    }
}

void QXYSeries::modelDataAboutToBeAdded(QModelIndex parent, int start, int end)
{
    Q_UNUSED(parent)
    //    Q_UNUSED(end)

    if (m_mapLimited) {
        if (start >= m_mapFirst + m_mapCount) {
            // the added data is below mapped area
            // therefore it has no relevance
            return;
        } else {
            // the added data is in the mapped area or before it and update is needed

            // check how many mapped items there is currently (before new items are added)
            // if the number of items currently is equal the m_mapCount then some needs to be removed from xychartitem
            // internal storage before new ones can be added

            int itemsToRemove = qMin(count() - qMax(start - m_mapFirst, 0), end - start + 1);
            if (m_mapCount == count()) {
                for (int i = 0; i < itemsToRemove; i++)
                    emit pointRemoved(qMin(end, count()) - i);
            }
        }
    } else {
        // map is not limited (it includes all the items starting from m_mapFirst till the end of model)
        // nothing to do
        //        emit pointAdded(qMax(start - m_mapFirst, 0));
    }
}

void QXYSeries::modelDataAdded(QModelIndex parent, int start, int end)
{
    Q_UNUSED(parent)
    //    Q_UNUSED(end)

    if (m_mapLimited) {
        if (start >= m_mapFirst + m_mapCount) {
            // the added data is below mapped area
            // therefore it has no relevance
            return;
        } else {
            // the added data is in the mapped area or before it
            // update needed
            if (count() > 0) {
                int toBeAdded = qMin(m_mapCount - (start - m_mapFirst), end - start + 1);
                for (int i = 0; i < toBeAdded; i++)
                    if (start + i >= m_mapFirst)
                        emit pointAdded(start + i);
            }
        }
    } else {
        // map is not limited (it included all the items starting from m_mapFirst till the end of model)
        for (int i = 0; i < end - start + 1; i++)
            emit pointAdded(start + i);
    }
}

void QXYSeries::modelDataAboutToBeRemoved(QModelIndex parent, int start, int end)
{
    Q_UNUSED(parent)
    //    Q_UNUSED(end)

    if (m_mapLimited) {
        if (start >= m_mapFirst + m_mapCount) {
            // the removed data is below mapped area
            // therefore it has no relevance
            return;
        } else {
            // the removed data is in the mapped area or before it
            // update needed

            // check how many items need to be removed from the xychartitem storage
            // the number equals the number of items that are removed and that lay before
            // or in the mapped area. Items that lay beyond the map do not count
            // the max is the current number of items in storage (count())
            int itemsToRemove = qMin(count(), qMin(end, m_mapFirst + m_mapCount - 1) - start + 1);
            for (int i = 0; i < itemsToRemove; i++)
                emit pointRemoved(start);
        }
    } else {
        // map is not limited (it included all the items starting from m_mapFirst till the end of model)
        for (int i = 0; i < end - start + 1; i++)
            emit pointRemoved(start);
    }
}

void QXYSeries::modelDataRemoved(QModelIndex parent, int start, int end)
{
    Q_UNUSED(parent)
    Q_UNUSED(end)

    // how many items there were before data was removed
    //    int oldCount = count() - 1;

    if (m_mapLimited) {
        if (start >= m_mapFirst + m_mapCount) {
            // the removed data is below mapped area
            // therefore it has no relevance
            return;
        } else {
            // if the current items count in the whole model is bigger than the index of the last item
            // that was removed than it means there are some extra items available

            int removedItemsCount = qMin(count(), qMin(end, m_mapFirst + m_mapCount - 1) - start + 1);
            int extraItemsAvailable = 0;
            if (m_mapOrientation == Qt::Vertical) {
//                int temp1 = m_model->rowCount();
//                int temp2 = (end - start + 1);
//                int temp3 = qMax(end + 1, m_mapFirst + m_mapCount);
                extraItemsAvailable = qMax(m_model->rowCount() + (end - start + 1) - qMax(end + 1, m_mapFirst + m_mapCount), 0);
            } else {
                extraItemsAvailable = qMax(m_model->columnCount() + (end - start + 1) - qMax(end + 1, m_mapFirst + m_mapCount), 0);
            }

            // if there are excess items available (below the mapped area) use them to repopulate mapped area
            int toBeAdded = qMin(extraItemsAvailable, removedItemsCount);
            for (int k = 0; k < toBeAdded; k++)
                emit pointAdded(m_mapFirst + m_mapCount - removedItemsCount + k);
        }
    } else {
        // data was removed from XYSeries interal storage. Nothing more to do
    }
}

bool QXYSeries::setModel(QAbstractItemModel *model) {

    // disconnect signals from old model
    if (m_model) {
        disconnect(m_model, 0, this, 0);
        m_mapX = -1;
        m_mapY = -1;
        m_mapFirst = 0;
        m_mapCount = 0;
        m_mapLimited = false;
        m_mapOrientation = Qt::Vertical;
    }

    // set new model
    if (model) {
        m_model = model;
        return true;
    } else {
        m_model = 0;
        return false;
    }
}

void QXYSeries::setModelMapping(int modelX, int modelY, Qt::Orientation orientation)
{
    if (m_model == 0)
        return;
    m_mapX = modelX;
    m_mapY = modelY;
    m_mapFirst = 0;
    m_mapOrientation = orientation;
    if (m_mapOrientation == Qt::Vertical) {
        //        m_mapCount = m_model->rowCount();
        connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
        connect(m_model,SIGNAL(rowsAboutToBeInserted(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeAdded(QModelIndex,int,int)));
        connect(m_model,SIGNAL(rowsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
        connect(m_model, SIGNAL(rowsAboutToBeRemoved(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeRemoved(QModelIndex,int,int)));
        connect(m_model, SIGNAL(rowsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
    } else {
        //        m_mapCount = m_model->columnCount();
        connect(m_model,SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(modelUpdated(QModelIndex, QModelIndex)));
        connect(m_model,SIGNAL(columnsAboutToBeInserted(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeAdded(QModelIndex,int,int)));
        connect(m_model,SIGNAL(columnsInserted(QModelIndex, int, int)), this, SLOT(modelDataAdded(QModelIndex,int,int)));
        connect(m_model, SIGNAL(columnsAboutToBeRemoved(QModelIndex, int, int)), this, SLOT(modelDataAboutToBeRemoved(QModelIndex,int,int)));
        connect(m_model, SIGNAL(columnsRemoved(QModelIndex, int, int)), this, SLOT(modelDataRemoved(QModelIndex,int,int)));
    }
}

void QXYSeries::setModelMappingShift(int first, int count)
{
    m_mapFirst = first;
    if (count == 0) {
        m_mapLimited = false;
    } else {
        m_mapCount = count;
        m_mapLimited = true;
    }
}

#include "moc_qxyseries.cpp"

QTCOMMERCIALCHART_END_NAMESPACE