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

**

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

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbWidgets module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** 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 developer.feedback@nokia.com.

**

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

#include "hblistview_p.h"

#include "hblistitemcontainer_p.h"

#include "hblistitemcontainer_p_p.h"

#include "hbmodeliterator.h"

#include <hbtumbleview.h>

#include <hbtumbleviewitem.h>

#include <hbevent.h>

#include <hbstyleoption_p.h>

#include <QGraphicsSceneMouseEvent>

#include <QStringListModel>

#include <QItemSelectionModel>

#include <QTapGesture>

#define HB_TUMBLE_ITEM_ANIMATION_TIME 500

#define HB_TUMBLE_PREFERRED_ITEMS 3

//#define HBTUMBLE_DEBUG

#ifdef HBTUMBLE_DEBUG

#include <QDebug>

#endif

class HbTumbleViewItemContainerPrivate;

class HbTumbleViewItemContainer:public HbListItemContainer

{

    Q_DECLARE_PRIVATE(HbTumbleViewItemContainer)

public:

    HbTumbleViewItemContainer(QGraphicsItem* parent = 0);    

    QPointF recycleItems(const QPointF &delta);

    void setLoopingEnabled(bool looping) ;

    bool isLoopingEnabled() const ;

    bool isLoopingNeeded() const;

    void removeItem(const QModelIndex &index, bool animate );

    void setModelIndexes(const QModelIndex &startIndex);

};

class HbTumbleViewItemContainerPrivate:public HbListItemContainerPrivate

{

    Q_DECLARE_PUBLIC(HbTumbleViewItemContainer)

public:

    HbTumbleViewItemContainerPrivate();

    QPointF recycleItems(const QPointF &delta);

    HbAbstractViewItem *shiftDownItem(QPointF& delta);

    HbAbstractViewItem *shiftUpItem(QPointF& delta);

    HbAbstractViewItem* item(const QModelIndex &index) const;

    bool mIsLooped;

};

class HbTumbleViewPrivate : public HbListViewPrivate

{

    Q_DECLARE_PUBLIC(HbTumbleView)

public:

    HbTumbleViewPrivate();

    qreal topBoundary();//virtual functions

    qreal bottomBoundary();

    virtual void updateScrollMetrics();

    virtual void scrollTo(const QModelIndex &index, HbAbstractItemView::ScrollHint hint);

    void init(QAbstractItemModel *model);

    void calculateItemHeight();

    void selectCurrentIndex(const QModelIndex& index);

    void selectMiddleItem();

    HbAbstractViewItem* getCenterItem();

    void createPrimitives();

    void _q_scrollingStarted();//private slot

    void _q_scrollingEnded();//private slot

    void setPressedState(HbAbstractViewItem *item);

private:

    qreal mHeight;

    QPointer<HbAbstractViewItem> mPrevSelectedItem;

    bool mInternalScroll;

    bool mStartup;//needed for layout request

    //geometry prob, some how loop setGeometry call is happening

    QRectF mPrevSetGeometryRect;

    QModelIndex mDelayedSelectIndex;

    QTimer mDelayedSelectTimer;

    //primitives

    int             mSelected;

    bool mNeedScrolling;

};

HbTumbleViewItemContainer::HbTumbleViewItemContainer(QGraphicsItem* parent )

    :HbListItemContainer(*(new HbTumbleViewItemContainerPrivate),parent)

{

}

QPointF HbTumbleViewItemContainer::recycleItems(const QPointF &delta)

{

    if(size().height() > itemView()->size().height()){

            Q_D(HbTumbleViewItemContainer);

            const qreal diff = d->getDiffWithoutScrollareaCompensation(delta);

            if(diff !=0.0){      

                  QPointF newDelta(0.0, 0.0);

                  qreal result = 0.0;

                  HbAbstractViewItem *item = 0;

                  if (diff < 0.0) {

                        while (-newDelta.y() > diff) {

                              item = d->shiftUpItem(newDelta);

                              if (!item) {

                                    break;

                              }

                        }

                  }

                  else {

                        while (-newDelta.y() < diff) {

                              item = d->shiftDownItem(newDelta);

                              if (!item) {

                                    break;

                              }

                        }

                  }

                  result = newDelta.y();

                  return QPointF(delta.x(),delta.y()+result);

            }

      }

    return delta;

}

void HbTumbleViewItemContainer::setLoopingEnabled(bool looped) {

    Q_D(HbTumbleViewItemContainer);

    d->mIsLooped = looped;    

    d->mItemView->scrollTo(d->mItemView->currentIndex(),HbAbstractItemView::PositionAtCenter);

    recycleItems(QPointF());

}

bool HbTumbleViewItemContainer::isLoopingEnabled() const {

    Q_D(const HbTumbleViewItemContainer);

    return d->mIsLooped;

}

bool HbTumbleViewItemContainer::isLoopingNeeded() const

{

    Q_D(const HbTumbleViewItemContainer);

      return (isLoopingEnabled() && (d->mItems.count() < maxItemCount()));

}

void HbTumbleViewItemContainer::removeItem(const QModelIndex &index, bool animate )

{

    Q_D(HbTumbleViewItemContainer);

    HbListItemContainer::removeItem(index,animate);

    if (d->mItems.count() < maxItemCount()) {

        d->updateItemBuffer();

    }

}

void HbTumbleViewItemContainer::setModelIndexes(const QModelIndex &startIndex)

{

    Q_D(HbAbstractItemContainer);

    if (!d->mItemView || !d->mItemView->model()) {

        return;

    }

    QModelIndex index = startIndex;

    if (!index.isValid()) {

        if (!d->mItems.isEmpty()) {

            index = d->mItems.first()->modelIndex();

        }

        if (!index.isValid()) {

            index = d->mItemView->modelIterator()->nextIndex(index);

        }

    }

    QModelIndexList indexList;

    int itemCount(d->mItems.count());

    if (itemCount != 0 && index.isValid()) {

        indexList.append(index);

    }

    for (int i = indexList.count(); i < itemCount; ++i) {

        index = d->mItemView->modelIterator()->nextIndex(indexList.last());

        if (index.isValid()) {

            indexList.append(index);

        } else {

            break;

        }

    }

    if(isLoopingEnabled() && indexList.count()<itemCount){

        QModelIndex firstModelIndex =  d->mItemView->modelIterator()->index(0,QModelIndex());

        indexList.append(firstModelIndex);

        for (int i = indexList.count(); i < itemCount; ++i) {

            index = d->mItemView->modelIterator()->nextIndex(indexList.last());

            if (index.isValid()) {

                indexList.append(index);

            } else {

                break;

            }

        }

    }

    for (int i = indexList.count(); i < itemCount; ++i) {

        index = d->mItemView->modelIterator()->previousIndex(indexList.first());

        if (index.isValid()) {

            indexList.prepend(index);

        } else {

            break;

        }

    }

    // if items have been added/removed in the middle of the buffer, there might be items

        // that can be reused at the end of the buffer. The following block will scan for

        // those items and move them in correct position

    int lastUsedItem = -1;

    for (int indexCounter = 0; indexCounter < indexList.count(); ++indexCounter) {

        HbAbstractViewItem *item = d->mItems.at(indexCounter);

        if (item && item->modelIndex() == indexList.at(indexCounter)) {

            lastUsedItem = indexCounter;

        } else {

            for (int itemCounter = lastUsedItem + 1; itemCounter < d->mItems.count(); itemCounter++) {

                HbAbstractViewItem *item2 = d->mItems.at(itemCounter);

                if (item2->modelIndex() == indexList.at(indexCounter)) {

                    d->mItems.swap(indexCounter, itemCounter);

                    itemRemoved(d->mItems.at(indexCounter), false);

                    itemRemoved(d->mItems.at(itemCounter), false);

                    itemAdded(qMin(indexCounter, itemCounter), d->mItems.at(qMin(indexCounter, itemCounter)), false);

                    itemAdded(qMax(indexCounter, itemCounter), d->mItems.at(qMax(indexCounter, itemCounter)), false);

                    lastUsedItem = itemCounter;

                    break;

                }

            }

        }

    }

    int indexCount(indexList.count());

    for (int i = 0; i < itemCount; ++i) {

        HbAbstractViewItem *item = d->mItems.at(i);

        HbAbstractViewItem *prototype = 0;

        // setItemModelIndex() is considered recycling. It is called only, if recycling is permitted

        if (i < indexCount) {

            prototype = d->itemPrototype(indexList.at(i));

        }

        if (prototype) {

            if (    prototype == item->prototype()

                &&  d->mItemRecycling) {

                setItemModelIndex(item, indexList.at(i));

            } else if (     d->mItemRecycling

                       ||   (   !d->mItemRecycling

                            &&  item->modelIndex() != indexList.at(i))) {

                d->deleteItem(item);

                insertItem(i, indexList.at(i));

            } // else: !d->mItemRecycling && item->modelIndex().isValid() == indexList.at(i))

        } else {

            d->deleteItem(item);

            itemCount--;

            i--;

        }

    }

}

HbTumbleViewItemContainerPrivate::HbTumbleViewItemContainerPrivate()

    : mIsLooped(false) 

{ 

}

HbAbstractViewItem *HbTumbleViewItemContainerPrivate::shiftDownItem(QPointF& delta)

{

    Q_Q(HbTumbleViewItemContainer);

    HbAbstractViewItem *item = 0;

    HbAbstractViewItem *lastItem = mItems.last();

    QModelIndex nextIndex = mItemView->modelIterator()->nextIndex(lastItem->modelIndex());

    if(mIsLooped && (!nextIndex.isValid())){

       nextIndex = mItemView->model()->index(0,0);

    }

    if (nextIndex.isValid()) {

        item = mItems.takeFirst();

        q->itemRemoved(item);

        delta.setY(delta.y() - item->size().height());

        mItems.append(item);

        q->setItemModelIndex(item, nextIndex);

        q->itemAdded(mItems.count() - 1, item);

    }

    return item;

}

HbAbstractViewItem *HbTumbleViewItemContainerPrivate::shiftUpItem(QPointF& delta)

{

    Q_Q(HbTumbleViewItemContainer);

    HbAbstractViewItem *item = 0;

    HbAbstractViewItem *firstItem = mItems.first();

    QModelIndex previousIndex = mItemView->modelIterator()->previousIndex(firstItem->modelIndex());

    if(mIsLooped && !previousIndex.isValid()){

        previousIndex = mItemView->model()->index(mItemView->model()->rowCount()-1,0);

    }

    if (previousIndex.isValid()) {

        item = mItems.takeLast();

        q->itemRemoved(item);

        mItems.insert(0, item);

        q->setItemModelIndex(item, previousIndex);

        qreal itemHeight=0;

        if (q->uniformItemSizes()) {

            itemHeight = mItems.last()->preferredHeight();

        } else {

            //This is time consuming and causes backwards srolling to be slower than forwards.

            //The sizehint of the item is dirty.

            itemHeight = item->preferredHeight();

        }

        delta.setY(delta.y() + itemHeight);

        q->itemAdded(0, item);

    }

    return item;

}

HbAbstractViewItem *HbTumbleViewItemContainerPrivate::item(const QModelIndex &index) const

{

    int itemCount = mItems.count();

    for(int i=0;i<itemCount;++i) {

        if(mItems.at(i)->modelIndex() == index) {

            return mItems.at(i);

        }

    }

    return 0;

}

HbTumbleViewPrivate::HbTumbleViewPrivate()

    :HbListViewPrivate()

    ,mHeight(10.0)

    ,mPrevSelectedItem(0)

    ,mInternalScroll(false)

    ,mStartup(true)

    ,mDelayedSelectIndex()

    ,mDelayedSelectTimer(0)

    ,mBackground(0)

    ,mFrame(0)

    ,mHighlight(0)

    ,mSelected(-1)

{

}

qreal HbTumbleViewPrivate::topBoundary()

{

    //top boundary and bottom boundary is different for tumble view

    //it is half item less than the middle of the view

    Q_Q( HbTumbleView );

    return (-(q->boundingRect().height()-mHeight)/2);

}

qreal HbTumbleViewPrivate::bottomBoundary()

{

    Q_Q ( HbTumbleView);    

    return mContents->boundingRect().height()-((q->boundingRect().height()+mHeight)/2);

} 

void HbTumbleViewPrivate::init(QAbstractItemModel *model)

{

    Q_Q(HbTumbleView);

    mNeedScrolling = true;

    //list settings

    HbTumbleViewItem *proto = new HbTumbleViewItem();

    proto->setFlag(QGraphicsItem::ItemIsFocusable,false);        

    q->setModel(model,proto);

    q->setSelectionMode(q->HbAbstractItemView::SingleSelection);

    q->setLongPressEnabled(false);

    q->setUniformItemSizes(true);

    q->setEnabledAnimations(HbAbstractItemView::TouchDown);

    //scroll area settings

    q->setClampingStyle(HbScrollArea::BounceBackClamping);

    q->setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    q->setHorizontalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    q->setFrictionEnabled(true);

    //don't want this to occupy entire screen. preferred is few items.

    q->setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Preferred);

    mDelayedSelectTimer.setSingleShot(true);

    bool b = q->connect(q,SIGNAL(scrollingStarted()),q,SLOT(_q_scrollingStarted()));

    Q_ASSERT(b);

    b = q->connect(q,SIGNAL(scrollingEnded()),q,SLOT(_q_scrollingEnded()));

    Q_ASSERT(b);

    createPrimitives();

}

void HbTumbleViewPrivate::selectMiddleItem()

{

    Q_Q(HbTumbleView);

    //scroll little amount so item settle's in

    if(!q->scene()) {

        return;

    }

    HbAbstractViewItem *item = getCenterItem();

    if(item) {

#ifdef HBTUMBLE_DEBUG  

        qDebug() << "HbTumbleViewPrivate::selectMiddleItem - " << item->modelIndex().row() ;

#endif

        selectCurrentIndex(item->modelIndex());

        mSelected = item->modelIndex().row();

    }

}

HbAbstractViewItem* HbTumbleViewPrivate::getCenterItem()

{

    Q_Q(HbTumbleView);

    if(!q->scene()) {

        return 0;

    }

    QPointF centerPt = q->mapToScene(q->boundingRect().center());

    return itemAt(centerPt);

}

void HbTumbleViewPrivate::scrollTo(const QModelIndex &index, HbAbstractItemView::ScrollHint hint)

{

    Q_Q(HbTumbleView);

#ifdef HBTUMBLE_DEBUG  

    qDebug() << "HbTumbleViewPrivate::scrollTo(" << index.row() << "," << hint << " )";

#endif

    if(!q->scene()) {

        return;

    }

    HbListViewPrivate::scrollTo(index, hint);

    HbAbstractViewItem *item = mContainer->itemByIndex(index);

    if(item) {

        setPressedState(item); 

    } 

#ifdef HBTUMBLE_DEBUG  

    else {

        qDebug() << "HbTumbleViewPrivate::scrollTo(" << index.row() << ",failed to get itembyindex";

    }

#endif

}

void HbTumbleViewPrivate::selectCurrentIndex(const QModelIndex& index)

{

    Q_Q(HbTumbleView);

    if(!mIsAnimating && !mIsScrolling) {