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

**

** 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 "hbdatepickerview_p.h"

#include "hbabstractitemview_p.h"

#include "hbabstractitemcontainer_p.h"

#include "hbabstractitemcontainer_p_p.h"

#include "hblistlayout_p.h"

#include "hbstyleoption_p.h"

#include "hbframeitem.h"

#include "hbstyleprimitivedata.h"

#include <hbmodeliterator.h>

#include <hbdatepickerviewitem_p.h>

#include <hbtapgesture.h>

#include <hbstyleframeprimitivedata.h>

#include <qmath.h>

#include <QTimeLine>

#include <QGraphicsItemAnimation>

#include <QGestureEvent>

#include <QGesture>

#include <QStringListModel>

#include <QCoreApplication>

#define HB_DATEPICKERVIEW_PREFERRED_ITEMS 3

class HbDatePickerViewPrivate : public HbAbstractItemViewPrivate

{

public:

    HbDatePickerViewPrivate();

    ~HbDatePickerViewPrivate();

    void _q_scrollingStarted();

    void _q_scrollingEnded();

    void _q_itemSelected(QPointF point);

    void createPrimitives();

    void updateScrollMetrics(){ mAbleToScrollY = true; }

    qreal topBoundary();

    qreal bottomBoundary();

    HbAbstractViewItem* getCenterItem();

    void slectItemAt(const QPointF& point,QGraphicsItem* itemToMap);

    void setItemState(HbAbstractViewItem* item = 0);

    QTimeLine *animationtimer;

    QGraphicsItemAnimation *animation;

    Q_DECLARE_PUBLIC(HbDatePickerView);

    QGraphicsObject   *mBackground;

    QGraphicsObject   *mFrame;//overlay

    QGraphicsObject   *mHighlight;

    QGraphicsObject   *mDivider;

   // bool tapActive;

    QPointer<HbAbstractViewItem> mPreviousItem;

    enum ViewState

    {

        NoState = 0,

        TapStarted = 1,

        ScrollStarted = 2

    };

    Q_DECLARE_FLAGS(ViewStates, ViewState)

    ViewStates viewStates;

};

class HbDatePickerContainerPrivate;

class HbDatePickerContainer:public HbAbstractItemContainer

{

public:

    HbDatePickerContainer(QGraphicsItem* parent = 0);

    void setModelIndexes(const QModelIndex &startIndex = QModelIndex());

    void resizeContainer();

    void itemAdded(int index, HbAbstractViewItem *item, bool animate);

    void itemRemoved(HbAbstractViewItem *item, bool animate);

    bool isLoopingEnabled(){return true;}

    bool isLoopingNeeded();

    int maxItemPossible()const;

protected:

    QPointF recycleItems(const QPointF &delta);

    int maxItemCount() const;

    HbAbstractViewItem *createDefaultPrototype() const;

    void viewResized(const QSizeF &size);

private:

    Q_DECLARE_PRIVATE(HbDatePickerContainer)

    friend class HbDatePickerView;

    friend class HbDatePickerViewPrivate;

};

class HbDatePickerContainerPrivate:public HbAbstractItemContainerPrivate

{

public:

    HbDatePickerContainerPrivate();

    HbAbstractViewItem *shiftDownItem(QPointF& delta);

    HbAbstractViewItem *shiftUpItem(QPointF& delta);

    qreal getSmallestItemHeight() const;

    void init();

    HbAbstractViewItem *item(const QModelIndex &index) const;

    HbListLayout *mLayout;

    Q_DECLARE_PUBLIC(HbDatePickerContainer)

};

HbDatePickerContainerPrivate::HbDatePickerContainerPrivate()

    :mLayout(0)

{

}

void HbDatePickerContainerPrivate::init()

{

    Q_Q(HbDatePickerContainer);

    mLayout = new HbListLayout();

    mLayout->setContentsMargins(0, 0, 0, 0);

    //mLayout->setPreferredWidth(q->size().width());

    q->setLayout(mLayout);

}

bool HbDatePickerContainer::isLoopingNeeded()

{

    Q_D(HbDatePickerContainer);

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

}

void HbDatePickerContainer::setModelIndexes(const QModelIndex &startIndex)

{

    Q_D(HbDatePickerContainer);

    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;

            }

        }

    }

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

        }

    }

}

void HbDatePickerContainer::resizeContainer()

{

    Q_D(HbAbstractItemContainer);

    if (d->mItemView) {

        resize(d->mItemView->size().width(), layout()->preferredHeight());

    } else {

        resize(0, layout()->preferredHeight());

    }

}

void HbDatePickerContainer::itemAdded(int index, HbAbstractViewItem *item, bool animate)

{

    Q_D(HbDatePickerContainer);

    d->mLayout->insertItem(index,item, animate);

}

void HbDatePickerContainer::itemRemoved(HbAbstractViewItem *item, bool animate)

{

    Q_D(HbDatePickerContainer);

    d->mLayout->removeItem(item, animate);

}

void HbDatePickerContainer::viewResized(const QSizeF &viewSize)

{

    QSizeF newSize = this->size();

    newSize.setWidth( viewSize.width() );

    resize( newSize );

}

QPointF HbDatePickerContainer::recycleItems(const QPointF &delta)

{

    Q_D(HbDatePickerContainer);

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

          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;

}

HbAbstractViewItem *HbDatePickerContainerPrivate::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;

}

HbAbstractViewItem *HbDatePickerContainerPrivate::shiftDownItem(QPointF& delta)

{

    Q_Q(HbDatePickerContainer);

    HbAbstractViewItem *item = 0;

    HbAbstractViewItem *lastItem = mItems.last();

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

    if(q->isLoopingEnabled() && (!nextIndex.isValid())){

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

    }

    if (nextIndex.isValid()) {

        item = mItems.takeFirst();

        q->itemRemoved(item,false);

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

        mItems.append(item);

        q->setItemModelIndex(item, nextIndex);

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

    }

    mBufferSize=4;

    return item;

}

HbAbstractViewItem *HbDatePickerContainerPrivate::shiftUpItem(QPointF& delta)

{

    Q_Q(HbDatePickerContainer);

    HbAbstractViewItem *item = 0;

    HbAbstractViewItem *firstItem = mItems.first();

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

    if(q->isLoopingEnabled() && !previousIndex.isValid()){

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

    }

    if (previousIndex.isValid()) {

        item = mItems.takeLast();

        q->itemRemoved(item,false);

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

    }

    return item;

}

qreal HbDatePickerContainerPrivate::getSmallestItemHeight() const

{

    Q_Q(const HbDatePickerContainer);

    qreal minHeight = 0.0;

    if (mItems.count() > 0) {

        minHeight = mLayout->smallestItemHeight();

    }

    if (minHeight == 0.0) {

        QModelIndex index;

        while (mItems.isEmpty()) {

            // in practise following conditions must apply: itemview is empty and scrollTo() has been called.

            // Starts populating items from given mFirstItemIndex

            if ( mFirstItemIndex.isValid()) {

                index = mFirstItemIndex;

                const_cast<QPersistentModelIndex&>(mFirstItemIndex) = QModelIndex();

            } else {

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

            }

            if (!index.isValid()) {

                break;

            }

            const_cast<HbDatePickerContainer *>(q)->insertItem(0, index);

        }

        if (!mItems.isEmpty()) {

            minHeight = mItems.first()->preferredHeight();

        }

    }

    return minHeight;

}

int HbDatePickerContainer::maxItemPossible()const

{

    Q_D(const HbDatePickerContainer);

    qreal minHeight = d->getSmallestItemHeight();

    if (minHeight > 0) {

        int countEstimate = qCeil(d->mItemView->boundingRect().height() / minHeight)

            + d->mBufferSize;

        return countEstimate;

    }

    return 0;

}

int HbDatePickerContainer::maxItemCount() const

{

    Q_D(const HbDatePickerContainer);

    int targetCount = HbAbstractItemContainer::maxItemCount();

    if (targetCount > 0

        && d->mItemRecycling

        && d->mPrototypes.count() <= 1) {

        qreal minHeight = d->getSmallestItemHeight();

        if (minHeight > 0) {

            int countEstimate = qCeil(d->mItemView->boundingRect().height() / minHeight)

                + d->mBufferSize;

            // This limits the targetCount not to be larger

            // than row count inside model.

            targetCount = qMin(targetCount, countEstimate);

        } else {

            targetCount = 0;

        }

    }

    return targetCount;

}

HbAbstractViewItem *HbDatePickerContainer::createDefaultPrototype()const

{

    return new HbDatePickerViewItem();

}

HbDatePickerContainer::HbDatePickerContainer(QGraphicsItem* parent)

    :HbAbstractItemContainer(*(new HbDatePickerContainerPrivate),parent )

{

    Q_D(HbDatePickerContainer);

    d->init();

}

HbDatePickerViewPrivate::HbDatePickerViewPrivate()

    :animationtimer(0),animation(0),

    mBackground(0),mFrame(0),mHighlight(0),mDivider(0),

    viewStates(NoState)

{

}

HbDatePickerViewPrivate::~HbDatePickerViewPrivate()

{

    if(animationtimer){

        if(animationtimer->state() != QTimeLine::NotRunning) {

            animationtimer->stop();

        }

        delete animationtimer;

        delete animation;

    }

}

HbDatePickerView::HbDatePickerView(QGraphicsItem *parent)

    :HbAbstractItemView(*(new HbDatePickerViewPrivate),new HbDatePickerContainer,new HbModelIterator(),parent)

{

    Q_D(HbDatePickerView);

    d->mAbleToScrollY = true;

    setSelectionMode(HbAbstractItemView::SingleSelection);

    setLongPressEnabled(false);

    setUniformItemSizes(true);

    setEnabledAnimations(HbAbstractItemView::TouchDown);

    setItemRecycling(true);

    //scroll area settings

    setClampingStyle(HbScrollArea::BounceBackClamping);

    setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    setHorizontalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);

    setFrictionEnabled(true);

    //dont want this to occupy entire screen. preferred is few items.

    setSizePolicy(QSizePolicy::Preferred,QSizePolicy::Preferred);

    bool b = connect(this,SIGNAL(scrollingStarted()),this,SLOT(_q_scrollingStarted()));

    Q_ASSERT(b);

    b = connect(this,SIGNAL(scrollingEnded()),this,SLOT(_q_scrollingEnded()));

    Q_ASSERT(b);

    d->createPrimitives();

    updatePrimitives();

    setModel(new QStringListModel());

}

HbDatePickerView::~HbDatePickerView()

{

}

void HbDatePickerView::rowsRemoved(const QModelIndex &parent, int start, int end)

{

    Q_D(HbDatePickerView);

    HbAbstractItemView::rowsRemoved(parent,start,end);

    HbDatePickerContainer* container = static_cast<HbDatePickerContainer*>(d->mContainer);

    container->d_func()->updateItemBuffer();

    //d->mContainer->layout()->activate();

    d->mPostponedScrollIndex = currentIndex();

    d->mPostponedScrollHint = PositionAtCenter;

    QCoreApplication::postEvent(this, new QEvent(QEvent::LayoutRequest));

}

void HbDatePickerView::rowsAboutToBeInserted(const QModelIndex &index, int start, int end)

{

    Q_D(HbDatePickerView);

    QPointF containerPos =  d->mContainer->pos();

    if(containerPos.y()>0){

        containerPos.setY(0);

        d->mContainer->setPos(containerPos);

    }

    HbAbstractItemView::rowsAboutToBeInserted(index,start,end);

}

void HbDatePickerView::rowsInserted(const QModelIndex &parent, int start, int end)

{

    Q_D(HbDatePickerView);

    HbAbstractItemView::rowsInserted(parent,start,end);