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

**

** 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>

#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 ;

};

class HbTumbleViewItemContainerPrivate:public HbListItemContainerPrivate

{

    Q_DECLARE_PUBLIC(HbTumbleViewItemContainer)

public:

    HbTumbleViewItemContainerPrivate();

    QPointF recycleItems(const QPointF &delta);

    HbAbstractViewItem *shiftDownItem(QPointF& delta);

    HbAbstractViewItem *shiftUpItem(QPointF& delta);

    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 selectMiddleItem();

    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

    QGraphicsItem   *mBackground;

    QGraphicsItem   *mFrame;//overlay

    QGraphicsItem   *mHighlight;

    int             mSelected;

    bool mNeedScrolling;

    QGraphicsItem   *mDivider;

};

HbTumbleViewItemContainer::HbTumbleViewItemContainer(QGraphicsItem* parent )

    :HbListItemContainer(*(new HbTumbleViewItemContainerPrivate),parent)

{

}

QPointF HbTumbleViewItemContainer::recycleItems(const QPointF &delta)

{

    Q_D(HbTumbleViewItemContainer);

    if (d->mPrototypes.count() != 1) {

        return delta;

    }

    QRectF viewRect(d->itemBoundingRect(d->mItemView));

    viewRect.moveTopLeft(viewRect.topLeft() + delta);

    int firstVisibleBufferIndex = -1;

    int lastVisibleBufferIndex = -1;

    d->firstAndLastVisibleBufferIndex(firstVisibleBufferIndex, lastVisibleBufferIndex, viewRect, false);

    int hiddenAbove = firstVisibleBufferIndex;

    int hiddenBelow = d->mItems.count() - lastVisibleBufferIndex - 1;

    if (d->mItems.count()

        && (firstVisibleBufferIndex == -1 || lastVisibleBufferIndex == -1)) {

        // All items out of sight.

        if (d->itemBoundingRect(d->mItems.first()).top() < 0) {

            // All items above view.

            hiddenAbove = d->mItems.count();

            hiddenBelow = 0;

        } else {

            // All items below view.

            hiddenAbove = 0;

            hiddenBelow = d->mItems.count();

        }

    }

    QPointF newDelta(delta);

    while (hiddenAbove > hiddenBelow + 1) {

        HbAbstractViewItem *item = d->shiftDownItem(newDelta);

        if (!item){

            break;

        }

        if (!d->visible(item, viewRect)) {

            hiddenBelow++;

        }

        hiddenAbove--;

    }

    while (hiddenBelow > hiddenAbove + 1) {

        HbAbstractViewItem *item = d->shiftUpItem(newDelta);

        if (!item) {

            break;

        }

        if (!d->visible( item, viewRect)) {

            hiddenAbove++;

        }

        hiddenBelow--;

    }

    return newDelta;

}

void HbTumbleViewItemContainer::setLoopingEnabled(bool looped) {

    Q_D(HbTumbleViewItemContainer);

    d->mIsLooped = looped;

}

bool HbTumbleViewItemContainer::isLoopingEnabled() const {

    Q_D(const HbTumbleViewItemContainer);

    return d->mIsLooped;

}

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;

}

HbTumbleViewPrivate::HbTumbleViewPrivate()

    :HbListViewPrivate()

    ,mHeight(10.0)

    ,mPrevSelectedItem(0)

    ,mInternalScroll(false)

    ,mStartup(true)

    ,mDelayedSelectIndex()

    ,mDelayedSelectTimer(0)

    ,mBackground(0)

    ,mFrame(0)

    ,mHighlight(0)

    ,mSelected(-1)

    ,mNeedScrolling(true)

    ,mDivider(0)

{

}

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);

    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;

    }

    if(item) {

#ifdef HBTUMBLE_DEBUG  

#endif

    }

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

}