/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtDeclarative module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "private/qdeclarativegridview_p.h"

#include "private/qdeclarativevisualitemmodel_p.h"

#include "private/qdeclarativeflickable_p_p.h"

#include "private/qdeclarativesmoothedanimation_p_p.h"

#include <qdeclarativeguard_p.h>

#include <qlistmodelinterface_p.h>

#include <QKeyEvent>

#include <qmath.h>

#include <math.h>

QT_BEGIN_NAMESPACE

//----------------------------------------------------------------------------

class FxGridItem

{

public:

    FxGridItem(QDeclarativeItem *i, QDeclarativeGridView *v) : item(i), view(v) {

        attached = static_cast<QDeclarativeGridViewAttached*>(qmlAttachedPropertiesObject<QDeclarativeGridView>(item));

        if (attached)

            attached->m_view = view;

    }

    ~FxGridItem() {}

    qreal rowPos() const { return (view->flow() == QDeclarativeGridView::LeftToRight ? item->y() : item->x()); }

    qreal colPos() const { return (view->flow() == QDeclarativeGridView::LeftToRight ? item->x() : item->y()); }

    qreal endRowPos() const {

        return view->flow() == QDeclarativeGridView::LeftToRight

                                ? item->y() + view->cellHeight() - 1

                                : item->x() + view->cellWidth() - 1;

    }

    void setPosition(qreal col, qreal row) {

        if (view->flow() == QDeclarativeGridView::LeftToRight) {

            item->setPos(QPointF(col, row));

        } else {

            item->setPos(QPointF(row, col));

        }

    }

    bool contains(int x, int y) const {

        return (x >= item->x() && x < item->x() + view->cellWidth() &&

                y >= item->y() && y < item->y() + view->cellHeight());

    }

    QDeclarativeItem *item;

    QDeclarativeGridView *view;

    QDeclarativeGridViewAttached *attached;

    int index;

};

//----------------------------------------------------------------------------

class QDeclarativeGridViewPrivate : public QDeclarativeFlickablePrivate

{

    Q_DECLARE_PUBLIC(QDeclarativeGridView)

public:

    QDeclarativeGridViewPrivate()

    : currentItem(0), flow(QDeclarativeGridView::LeftToRight)

    , visibleIndex(0) , currentIndex(-1)

    , cellWidth(100), cellHeight(100), columns(1), requestedIndex(-1), itemCount(0)

    , highlightRangeStart(0), highlightRangeEnd(0), highlightRange(QDeclarativeGridView::NoHighlightRange)

    , highlightComponent(0), highlight(0), trackedItem(0)

    , moveReason(Other), buffer(0), highlightXAnimator(0), highlightYAnimator(0)

    , highlightMoveDuration(150)

    , bufferMode(BufferBefore | BufferAfter), snapMode(QDeclarativeGridView::NoSnap)

    , ownModel(false), wrap(false), autoHighlight(true)

    , fixCurrentVisibility(false), lazyRelease(false), layoutScheduled(false)

    , deferredRelease(false), haveHighlightRange(false) {}

    void init();

    void clear();

    FxGridItem *createItem(int modelIndex);

    void releaseItem(FxGridItem *item);

    void refill(qreal from, qreal to, bool doBuffer=false);

    void updateGrid();

    void scheduleLayout();

    void layout();

    void updateUnrequestedIndexes();

    void updateUnrequestedPositions();

    void updateTrackedItem();

    void createHighlight();

    void updateHighlight();

    void updateCurrent(int modelIndex);

    void fixupPosition();

    FxGridItem *visibleItem(int modelIndex) const {

        if (modelIndex >= visibleIndex && modelIndex < visibleIndex + visibleItems.count()) {

            for (int i = modelIndex - visibleIndex; i < visibleItems.count(); ++i) {

                FxGridItem *item = visibleItems.at(i);

                if (item->index == modelIndex)

                    return item;

            }

        }

        return 0;

    }

    qreal position() const {

        Q_Q(const QDeclarativeGridView);

        return flow == QDeclarativeGridView::LeftToRight ? q->contentY() : q->contentX();

    }

    void setPosition(qreal pos) {

        Q_Q(QDeclarativeGridView);

        if (flow == QDeclarativeGridView::LeftToRight)

            q->setContentY(pos);

        else

            q->setContentX(pos);

    }

    int size() const {

        Q_Q(const QDeclarativeGridView);

        return flow == QDeclarativeGridView::LeftToRight ? q->height() : q->width();

    }

    qreal startPosition() const {

        qreal pos = 0;

        if (!visibleItems.isEmpty())

            pos = visibleItems.first()->rowPos() - visibleIndex / columns * rowSize();

        return pos;

    }

    qreal endPosition() const {

        qreal pos = 0;

        if (model && model->count())

            pos = rowPosAt(model->count() - 1) + rowSize();

        return pos;

    }

    bool isValid() const {

        return model && model->count() && model->isValid();

    }

    int rowSize() const {

        return flow == QDeclarativeGridView::LeftToRight ? cellHeight : cellWidth;

    }

    int colSize() const {

        return flow == QDeclarativeGridView::LeftToRight ? cellWidth : cellHeight;

    }

    qreal colPosAt(int modelIndex) const {

        if (FxGridItem *item = visibleItem(modelIndex))

            return item->colPos();

        if (!visibleItems.isEmpty()) {

            if (modelIndex < visibleIndex) {

                int count = (visibleIndex - modelIndex) % columns;

                int col = visibleItems.first()->colPos() / colSize();

                col = (columns - count + col) % columns;

                return col * colSize();

            } else {

                int count = columns - 1 - (modelIndex - visibleItems.last()->index - 1) % columns;

                return visibleItems.last()->colPos() - count * colSize();

            }

        } else {

            return (modelIndex % columns) * colSize();

        }

        return 0;

    }

    qreal rowPosAt(int modelIndex) const {

        if (FxGridItem *item = visibleItem(modelIndex))

            return item->rowPos();

        if (!visibleItems.isEmpty()) {

            if (modelIndex < visibleIndex) {

                int firstCol = visibleItems.first()->colPos() / colSize();

                int col = visibleIndex - modelIndex + (columns - firstCol - 1);

                int rows = col / columns;

                return visibleItems.first()->rowPos() - rows * rowSize();

            } else {

                int count = modelIndex - visibleItems.last()->index;

                int col = visibleItems.last()->colPos() + count * colSize();

                int rows = col / (columns * colSize());

                return visibleItems.last()->rowPos() + rows * rowSize();

            }

        } else {

             return (modelIndex / columns) * rowSize();

        }

        return 0;

    }

    FxGridItem *firstVisibleItem() const {

        const qreal pos = position();

        for (int i = 0; i < visibleItems.count(); ++i) {

            FxGridItem *item = visibleItems.at(i);

            if (item->index != -1 && item->endRowPos() > pos)

                return item;

        }

        return visibleItems.count() ? visibleItems.first() : 0;

    }

    // Map a model index to visibleItems list index.

    // These may differ if removed items are still present in the visible list,

    // e.g. doing a removal animation

    int mapFromModel(int modelIndex) const {

        if (modelIndex < visibleIndex || modelIndex >= visibleIndex + visibleItems.count())

            return -1;

        for (int i = 0; i < visibleItems.count(); ++i) {

            FxGridItem *listItem = visibleItems.at(i);

            if (listItem->index == modelIndex)

                return i + visibleIndex;

            if (listItem->index > modelIndex)

                return -1;

        }

        return -1; // Not in visibleList

    }

    qreal snapPosAt(qreal pos) {

        qreal snapPos = 0;

        if (!visibleItems.isEmpty()) {

            pos += rowSize()/2;

            snapPos = visibleItems.first()->rowPos() - visibleIndex / columns * rowSize();

            snapPos = pos - fmodf(pos - snapPos, qreal(rowSize()));

        }

        return snapPos;

    }

    int snapIndex() {

        int index = currentIndex;

        for (int i = 0; i < visibleItems.count(); ++i) {

            FxGridItem *item = visibleItems[i];

            if (item->index == -1)

                continue;

            qreal itemTop = item->rowPos();

            if (itemTop >= highlight->rowPos()-rowSize()/2 && itemTop < highlight->rowPos()+rowSize()/2) {

                index = item->index;

                if (item->colPos() >= highlight->colPos()-colSize()/2 && item->colPos() < highlight->colPos()+colSize()/2)

                    return item->index;

            }

        }

        return index;

    }

    virtual void itemGeometryChanged(QDeclarativeItem *item, const QRectF &newGeometry, const QRectF &oldGeometry) {

        Q_Q(const QDeclarativeGridView);

        QDeclarativeFlickablePrivate::itemGeometryChanged(item, newGeometry, oldGeometry);

        if (item == q) {

            if (newGeometry.height() != oldGeometry.height()

                || newGeometry.width() != oldGeometry.width()) {

                if (q->isComponentComplete()) {

                    updateGrid();

                    scheduleLayout();

                }

            }

        }

    }

    virtual void fixup(AxisData &data, qreal minExtent, qreal maxExtent);

    virtual void flick(AxisData &data, qreal minExtent, qreal maxExtent, qreal vSize,

                QDeclarativeTimeLineCallback::Callback fixupCallback, qreal velocity);

    // for debugging only

    void checkVisible() const {

        int skip = 0;

        for (int i = 0; i < visibleItems.count(); ++i) {

            FxGridItem *listItem = visibleItems.at(i);

            if (listItem->index == -1) {

                ++skip;

            } else if (listItem->index != visibleIndex + i - skip) {

                for (int j = 0; j < visibleItems.count(); j++)

                    qDebug() << " index" << j << "item index" << visibleItems.at(j)->index;

                qFatal("index %d %d %d", visibleIndex, i, listItem->index);

            }

        }

    }

    QDeclarativeGuard<QDeclarativeVisualModel> model;

    QVariant modelVariant;

    QList<FxGridItem*> visibleItems;

    QHash<QDeclarativeItem*,int> unrequestedItems;

    FxGridItem *currentItem;

    QDeclarativeGridView::Flow flow;

    int visibleIndex;

    int currentIndex;

    int cellWidth;

    int cellHeight;

    int columns;

    int requestedIndex;

    int itemCount;

    qreal highlightRangeStart;

    qreal highlightRangeEnd;

    QDeclarativeGridView::HighlightRangeMode highlightRange;

    QDeclarativeComponent *highlightComponent;

    FxGridItem *highlight;

    FxGridItem *trackedItem;

    enum MovementReason { Other, SetIndex, Mouse };

    MovementReason moveReason;

    int buffer;

    QSmoothedAnimation *highlightXAnimator;

    QSmoothedAnimation *highlightYAnimator;

    int highlightMoveDuration;

    enum BufferMode { NoBuffer = 0x00, BufferBefore = 0x01, BufferAfter = 0x02 };

    int bufferMode;

    QDeclarativeGridView::SnapMode snapMode;

    bool ownModel : 1;

    bool wrap : 1;

    bool autoHighlight : 1;

    bool fixCurrentVisibility : 1;

    bool lazyRelease : 1;

    bool layoutScheduled : 1;

    bool deferredRelease : 1;

    bool haveHighlightRange : 1;

};

void QDeclarativeGridViewPrivate::init()

{

    Q_Q(QDeclarativeGridView);

    QObject::connect(q, SIGNAL(movementEnded()), q, SLOT(animStopped()));

    q->setFlag(QGraphicsItem::ItemIsFocusScope);

    q->setFlickableDirection(QDeclarativeFlickable::VerticalFlick);

    addItemChangeListener(this, Geometry);

}

void QDeclarativeGridViewPrivate::clear()

{

    for (int i = 0; i < visibleItems.count(); ++i)

        releaseItem(visibleItems.at(i));

    visibleItems.clear();

    visibleIndex = 0;

    releaseItem(currentItem);

    currentItem = 0;

    createHighlight();

    trackedItem = 0;

    itemCount = 0;

}

FxGridItem *QDeclarativeGridViewPrivate::createItem(int modelIndex)

{

    Q_Q(QDeclarativeGridView);

    // create object

    requestedIndex = modelIndex;

    FxGridItem *listItem = 0;

    if (QDeclarativeItem *item = model->item(modelIndex, false)) {

        listItem = new FxGridItem(item, q);

        listItem->index = modelIndex;

        if (model->completePending()) {

            // complete

            listItem->item->setZValue(1);

            listItem->item->setParentItem(q->viewport());

            model->completeItem();

        } else {

            listItem->item->setParentItem(q->viewport());

        }

        unrequestedItems.remove(listItem->item);

    }

    requestedIndex = -1;

    return listItem;

}

void QDeclarativeGridViewPrivate::releaseItem(FxGridItem *item)

{

    Q_Q(QDeclarativeGridView);

    if (!item || !model)

        return;

    if (trackedItem == item) {

        QObject::disconnect(trackedItem->item, SIGNAL(yChanged()), q, SLOT(trackedPositionChanged()));

        QObject::disconnect(trackedItem->item, SIGNAL(xChanged()), q, SLOT(trackedPositionChanged()));

        trackedItem = 0;

    }

    if (model->release(item->item) == 0) {

        // item was not destroyed, and we no longer reference it.

        unrequestedItems.insert(item->item, model->indexOf(item->item, q));

    }

    delete item;

}

void QDeclarativeGridViewPrivate::refill(qreal from, qreal to, bool doBuffer)

{

    Q_Q(QDeclarativeGridView);

    if (!isValid() || !q->isComponentComplete())

        return;

    itemCount = model->count();

    qreal bufferFrom = from - buffer;

    qreal bufferTo = to + buffer;

    qreal fillFrom = from;

    qreal fillTo = to;

    if (doBuffer && (bufferMode & BufferAfter))

        fillTo = bufferTo;

    if (doBuffer && (bufferMode & BufferBefore))

        fillFrom = bufferFrom;

    bool changed = false;

    int colPos = colPosAt(visibleIndex);

    int rowPos = rowPosAt(visibleIndex);

    int modelIndex = visibleIndex;

    if (visibleItems.count()) {

        rowPos = visibleItems.last()->rowPos();

        colPos = visibleItems.last()->colPos() + colSize();

        if (colPos > colSize() * (columns-1)) {

            colPos = 0;

            rowPos += rowSize();

        }

        int i = visibleItems.count() - 1;

        while (i > 0 && visibleItems.at(i)->index == -1)

            --i;

        modelIndex = visibleItems.at(i)->index + 1;

    }

    int colNum = colPos / colSize();

    FxGridItem *item = 0;

    // Item creation and release is staggered in order to avoid

    // creating/releasing multiple items in one frame

    // while flicking (as much as possible).

    while (modelIndex < model->count() && rowPos <= fillTo + rowSize()*(columns - colNum)/(columns+1)) {

//        qDebug() << "refill: append item" << modelIndex;

        if (!(item = createItem(modelIndex)))

            break;

        item->setPosition(colPos, rowPos);

        visibleItems.append(item);

        colPos += colSize();

        colNum++;

        if (colPos > colSize() * (columns-1)) {

            colPos = 0;

            colNum = 0;

            rowPos += rowSize();

        }

        ++modelIndex;

        changed = true;

        if (doBuffer) // never buffer more than one item per frame

            break;

    }

    if (visibleItems.count()) {

        rowPos = visibleItems.first()->rowPos();

        colPos = visibleItems.first()->colPos() - colSize();

        if (colPos < 0) {

            colPos = colSize() * (columns - 1);

            rowPos -= rowSize();

        }

    }

    colNum = colPos / colSize();

    while (visibleIndex > 0 && rowPos + rowSize() - 1 >= fillFrom - rowSize()*(colNum+1)/(columns+1)){

//        qDebug() << "refill: prepend item" << visibleIndex-1 << "top pos" << rowPos << colPos;

        if (!(item = createItem(visibleIndex-1)))

            break;

        --visibleIndex;

        item->setPosition(colPos, rowPos);

        visibleItems.prepend(item);

        colPos -= colSize();

        colNum--;

        if (colPos < 0) {

            colPos = colSize() * (columns - 1);

            colNum = columns-1;

            rowPos -= rowSize();

        }

        changed = true;

        if (doBuffer) // never buffer more than one item per frame

            break;

    }

    if (!lazyRelease || !changed || deferredRelease) { // avoid destroying items in the same frame that we create

        while (visibleItems.count() > 1

               && (item = visibleItems.first())

                    && item->endRowPos() < bufferFrom - rowSize()*(item->colPos()/colSize()+1)/(columns+1)) {

            if (item->attached->delayRemove())

                break;

//            qDebug() << "refill: remove first" << visibleIndex << "top end pos" << item->endRowPos();

            if (item->index != -1)

                visibleIndex++;

            visibleItems.removeFirst();

            releaseItem(item);

            changed = true;

        }

        while (visibleItems.count() > 1

               && (item = visibleItems.last())

                    && item->rowPos() > bufferTo + rowSize()*(columns - item->colPos()/colSize())/(columns+1)) {

            if (item->attached->delayRemove())

                break;

//            qDebug() << "refill: remove last" << visibleIndex+visibleItems.count()-1;

            visibleItems.removeLast();

            releaseItem(item);

            changed = true;

        }

        deferredRelease = false;

    } else {

        deferredRelease = true;

    }

    if (changed) {

        if (flow == QDeclarativeGridView::LeftToRight)

            q->setContentHeight(endPosition() - startPosition());

        else

            q->setContentWidth(endPosition() - startPosition());