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

**

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

#include "hbabstractitemcontainer_p_p.h"

#include "hbabstractviewitem.h"

#include "hbabstractitemview.h"

#include "hbmodeliterator.h"

#include <hbapplication.h>

#include <QGraphicsLayout>

#include <QGraphicsSceneResizeEvent>

#include <QEvent>

#include <QDebug>

/*!   

    HbAbstractItemContainer is used in HbAbstractItemView to hold the layout and view items.

    Container should have a layout, otherwise its size is zero always.

    HbAbstractItemContainer can have any kind of layout as it child.

*/

/*!

    Function is called after new \a item was added into \a index position into

    container.

*/

/*!

    Function is called after the \a item was removed from the container. 

*/

/*!

    Function is called when container needs to be resized.

*/

/*!

    Returns the default prototype.

    Subclasses of this class must implement this function to introduce their own default prototype. 

    Default prototype is used to create view items unless the class user excplicitly sets prototype with setItemPrototype method. 

    Implementation of this method must construct and return a new view item widget. 

*/

const int HB_DEFAULT_BUFFERSIZE = 4;

const int UpdateItemBufferEvent = QEvent::registerEventType();

HbAbstractItemContainerPrivate::HbAbstractItemContainerPrivate() : 

    HbWidgetPrivate(),

    mItemView(0),

    mBufferSize(HB_DEFAULT_BUFFERSIZE),

    mItemRecycling(false),

    mUniformItemSizes(false)

{

}

HbAbstractItemContainerPrivate::~HbAbstractItemContainerPrivate()

{

}

void HbAbstractItemContainerPrivate::init()

{

    Q_Q(HbAbstractItemContainer);

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

}

/*!

   Returns given item's bounding rectangle in scene coordinates.

 */

QRectF HbAbstractItemContainerPrivate::itemBoundingRect(const QGraphicsItem *item) const

{

    Q_Q(const HbAbstractItemContainer);

    if (q->layout()) {

        q->layout()->activate();

    }

    return item->mapToItem(mItemView, item->boundingRect()).boundingRect();

}

void HbAbstractItemContainerPrivate::firstAndLastVisibleBufferIndex(

        int& firstVisibleBufferIndex,

        int& lastVisibleBufferIndex,

        const QRectF &viewRect,

        bool fullyVisible) const

{

    Q_Q(const HbAbstractItemContainer);

    if (q->layout() && !q->layout()->isActivated()) {

        q->layout()->activate();

    }

    firstVisibleBufferIndex = -1;

    lastVisibleBufferIndex = -1;

    int count = mItems.count();

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

        if (visible(mItems.at(i), viewRect, fullyVisible)) {

            if (firstVisibleBufferIndex == -1) {

                firstVisibleBufferIndex = i;

            }

            lastVisibleBufferIndex = i;

        } else if ( lastVisibleBufferIndex != -1 ) {

            // no need to check the remaining ones.

            break;

        }

    }

}

/*!

    \private

    Returns true if given item is located within viewport (i.e.  view), otherwise

    returns false. If fullyVisible parameter is true method will return true only

    for item that is shown fully. In this case for partially visible items false is returned.

*/

bool HbAbstractItemContainerPrivate::visible(HbAbstractViewItem* item, const QRectF &viewRect, bool fullyVisible) const

{

    if (item) {

        QRectF itemRect(itemBoundingRect(item));

        if (fullyVisible) {

            if (viewRect.contains(itemRect)) {

                return true;

            }

        } else {

            if (viewRect.intersects(itemRect)) {

                return true;

            }

        }

    }

    return false;

}

/*!

  Clears the prototype list and deletes the prototypes.

*/

void HbAbstractItemContainerPrivate::deletePrototypes()

{

    qDeleteAll(mPrototypes);

    mPrototypes.clear();

}

int HbAbstractItemContainerPrivate::findStateItem(const QModelIndex &index) const

{

    for (int current = 0; current < mItemStateList.count(); ++current) {

        if (mItemStateList.at(current).index == index) {

            return current;

        }

    }

    return -1;

}

void HbAbstractItemContainerPrivate::initPrototype(HbAbstractViewItem *prototype) const

{

    prototype->setParentItem(mItemView);

    prototype->setItemView(mItemView);

    prototype->resize(QSizeF(0, 0));

    prototype->hide();

}

HbAbstractViewItem* HbAbstractItemContainerPrivate::createItem(const QModelIndex& index)

{

    Q_Q(HbAbstractItemContainer);

    HbAbstractViewItem *result = 0;

    HbAbstractViewItem *prototype = itemPrototype(index);

    if (prototype) {

        result = q_check_ptr(prototype->createItem());

        Q_ASSERT_X(result->prototype() == prototype, "HbAbstractItemContainerPrivate::createItem", "Copy constructor must be used for creating concrete view items in createItem(). Create your custom view item with 'new YourCustomViewItem(*this)' instead of 'new YourCustomViewItem(this)'");

        result->setParentItem(q);

        emit q->itemCreated(result);

    }

    return result;

}

HbAbstractViewItem* HbAbstractItemContainerPrivate::itemPrototype(const QModelIndex& index) const

{

    Q_Q(const HbAbstractItemContainer);

    if (mPrototypes.isEmpty()) {

        HbAbstractViewItem *defaultPrototype = q->createDefaultPrototype();

        if (defaultPrototype) {

            initPrototype(defaultPrototype);

            mPrototypes.append(defaultPrototype);

        }

    }

    HbAbstractViewItem *result = 0;

    int count = mPrototypes.count() - 1;

    for (int i = count; i >= 0; i--) {

        if (mPrototypes[i]->canSetModelIndex(index)) {

            result = mPrototypes[i];

            break;

        }

    }

    return result;

}

/*!

    \private

    Updates item buffer to contain correct amount of items for the current situation.

*/

void HbAbstractItemContainerPrivate::updateItemBuffer()

{

    Q_Q(HbAbstractItemContainer);

    if (!mItemView) {

        return;

    }

    int targetCount = q->maxItemCount();

    int itemCount = mItems.count();

    if (itemCount == targetCount) {

        return;

    }

    // Store the first item position related to view.

    QPointer<HbAbstractViewItem> firstItem = mItems.value(qMax(0, itemCount - targetCount));

    QPointF firstItemPos;

    if (firstItem) {

        firstItemPos = itemBoundingRect(firstItem).topLeft();

    }

    // Perform the incresing/decreasing

    if (itemCount < targetCount) {

        increaseBufferSize(targetCount - itemCount);

    } else {

        decreaseBufferSize(itemCount - targetCount);

    }

    restoreItemPosition(firstItem, firstItemPos);

}

/*!

    Increases the item buffer size with given \a amount.

    First tries to add as many items after the last item with valid

    index as it can. If there is not enough valid indexes then inserts items

    before the first item with valid index.

*/

void HbAbstractItemContainerPrivate::increaseBufferSize(int amount)

{

    Q_Q(HbAbstractItemContainer);

    // Append new items.

    QModelIndex index;

    for (int i = mItems.count() - 1; i >= 0; --i) {

        index = mItems.at(i)->modelIndex();

        if (index.isValid()) {

            break;

        }

    }

    int itemsAdded = 0;

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

    // Starts populating items from given mFirstItemIndex

    if (    !index.isValid()

        &&  mFirstItemIndex.isValid()) {

        index = mFirstItemIndex;

        q->insertItem(mItems.count(), index);

        itemsAdded++;

        mFirstItemIndex = QModelIndex();

    }

    while (itemsAdded < amount) {

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

        if (!index.isValid()) {

            break;

        }

        q->insertItem(mItems.count(), index);

        itemsAdded++;

    }

    if (itemsAdded == amount) {

        return;

    } 

    // Prepend new items.

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

        index = mItems.at(i)->modelIndex();

        if (index.isValid()) {

            break;

        }

    }

    while (itemsAdded < amount) {

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

        if (!index.isValid()) {

            break;

        }

        q->insertItem(0, index);

        itemsAdded++;

    }

}

/*!

    Decreases the item buffer size with given \a amount.

    Tries to avoid deleting visible items and keep the buffer balanced.

*/

void HbAbstractItemContainerPrivate::decreaseBufferSize(int amount)

{

    Q_UNUSED(amount)

    int firstVisible = 0;

    int lastVisible = 0;

    firstAndLastVisibleBufferIndex(firstVisible, lastVisible, mItemView->geometry(), false);

    int deletableItemsOnTop = firstVisible - 1;

    int deletableItemsOnBottom = mItems.count() - lastVisible - 1;

    int itemsDeleted = 0;

    HbAbstractViewItem* item = 0;

    // in decreasing the buffer we try to keep it balanced

    while (itemsDeleted < amount ) {

        if (deletableItemsOnTop > deletableItemsOnBottom) {

            item = mItems.takeFirst();

            deletableItemsOnTop--;

        } else {

            item = mItems.takeLast();

            deletableItemsOnBottom--;

        }

        deleteItem(item);

        ++itemsDeleted;

     }

}

/*!

    \private

*/

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

{

    int itemCount = mItems.count();

    if (index.isValid()) {

        if (itemCount > 0) { 

            HbModelIterator *iterator = mItemView->modelIterator();

            int positionFirstIndex = iterator->indexPosition(mItems.first()->modelIndex());

            // when new items are inserted, they will appear in the end of container before a model index is assigned to them

            if (positionFirstIndex >= 0) {

                int positionIndex = iterator->indexPosition(index);

                HbAbstractViewItem *item = mItems.value(positionIndex - positionFirstIndex);

                if (    item

                    &&  item->modelIndex() == index) { 

                    return item;

                }

            }

        }

    } else {

        // searching items e.g. removed from model 

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

            if (!mItems.at(i)->modelIndex().isValid()) {

                return mItems.at(i);

            }

        }

    }

    return 0;

}

/*!

    \private

    Removes \a item with model index \a index.

*/

void HbAbstractItemContainerPrivate::doRemoveItem(HbAbstractViewItem *item, const QModelIndex &index, bool animate)

{

    if (item) {

        deleteItem(item, animate);

        if (!index.isValid()) {

            mItemStates.remove(index);

        }

    }

}

/*!

    \private

    Deletes \a item.

*/

void HbAbstractItemContainerPrivate::deleteItem(HbAbstractViewItem *item, bool animate)

{

    Q_Q(HbAbstractItemContainer);

    q->setItemTransientState(item->modelIndex(), item->transientState());

    mItems.removeOne(item);

    q->itemRemoved(item, animate);

#ifndef HB_EFFECTS

    delete item;

#else

    if (!HbEffect::effectRunning(item, "disappear") 

        && !HbEffect::effectRunning(item, "collapse")) {

        delete item;

    }

#endif

}

/*

    \private

    The previous or the next index must be in the buffer. We cannot assume in this base class 

    that the container is a list we just have to loop through the items and find if the previous

    or next exist in the buffer. Next index should not be the first one in the buffer and the

    previous index should not be the last one in the buffer in order this index to the buffer.

*/

bool HbAbstractItemContainerPrivate::intoContainerBuffer(const QModelIndex &index) const

{    

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

    QModelIndex previousIndex = mItemView->modelIterator()->previousIndex(index);

    int itemCount = mItems.count();

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

        QModelIndex currentIndex = mItems.at(i)->modelIndex();

        if (currentIndex == nextIndex && i != 0){

            return true;

        } else if (currentIndex == previousIndex && i != (itemCount - 1)) {

            return true;

        }

    }

    return false;

} 

int HbAbstractItemContainerPrivate::containerBufferIndexForModelIndex(const QModelIndex &index) const

{   

    int bufferIndex = 0;

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

    QModelIndex previousIndex = mItemView->modelIterator()->previousIndex(index);

    while (bufferIndex < mItems.count()) {

        QModelIndex currentIndex = mItems.at(bufferIndex)->modelIndex();

        if (currentIndex == nextIndex) {

            break;

        }

        ++bufferIndex;

        if (currentIndex == previousIndex) {

            break;

        }

    }

    return bufferIndex;

}

void HbAbstractItemContainerPrivate::restoreItemPosition(HbAbstractViewItem *item, const QPointF &position)

{

    Q_Q(HbAbstractItemContainer);

    if (item) {

        QPointF delta = itemBoundingRect(item).topLeft() - position;

        if (!delta.isNull()) {

            q->setPos(q->pos() - delta);

            adjustContent();

        }

    }

}

void HbAbstractItemContainerPrivate::insertItem(HbAbstractViewItem *item, int pos, const QModelIndex &index, bool animate)

{

    Q_Q(HbAbstractItemContainer);

    if (item) {

        mItems.insert(pos, item);

        q->itemAdded(pos, item, animate);

        q->setItemModelIndex(item, index);

    }

}

qreal HbAbstractItemContainerPrivate::getDiffWithoutScrollareaCompensation(const QPointF &delta) const

{

    Q_Q( const HbAbstractItemContainer);

    const QSizeF containerSize(q->size());

    const QPointF containerPos(q->pos());

    qreal diff = 0.0;

    qreal invisibleArea = 0.0;

    if (delta.y() > 0) {

        // space at the bottom

        QSizeF viewSize = mItemView->size();

        invisibleArea = containerSize.height() - viewSize.height() + containerPos.y();

        if (invisibleArea < delta.y()) {

            diff = delta.y() - invisibleArea;

        }

    } else {

        // space at the top

        invisibleArea = -containerPos.y();

        if (containerPos.y() > delta.y()) {

            diff = delta.y() + invisibleArea;

        }

    }

    return diff;

}