/****************************************************************************
**
** 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 <hbgridview_p.h>
#include <hbgridlayout_p.h>
#include <hbgriditemcontainer_p.h>
#include <hbgridviewitem_p.h>

#include <hbgesturefilter.h>
#include <hbgridviewitem.h>
#include <hbscrollbar.h>

#include "hbmodeliterator.h"

#include <QDebug>
#include <QGraphicsView>


const QString KDefaultLayoutOption = "default";

HbGridViewPrivate::HbGridViewPrivate() : 
    mIconVisible(true), 
    mTextVisible(true)
{
}

HbGridViewPrivate::~HbGridViewPrivate()
{
}

void HbGridViewPrivate::init()
{
    Q_Q(HbGridView);
    q->setClampingStyle(q->BounceBackClamping);
    q->setScrollingStyle(q->PanOrFlick);
    q->setVerticalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);
    q->setHorizontalScrollBarPolicy(HbScrollArea::ScrollBarAlwaysOff);
    q->setFrictionEnabled(false);
    q->setFlag(QGraphicsItem::ItemClipsToShape);
    QObject::connect(q, SIGNAL(scrollDirectionsChanged(Qt::Orientations)),
                      q, SLOT(scrollDirectionChanged(Qt::Orientations)));
    mLayoutOptionName = KDefaultLayoutOption;
}

/*
 Utility function to find a item under certain scene pixel
 */
QModelIndex HbGridViewPrivate::itemIndexUnder(const QPointF& point)
{
    Q_Q ( HbGridView );
    QModelIndex ret = QModelIndex();
    HbAbstractViewItem* hitItem = 0;
    QList<QGraphicsItem *> items = q->scene()->items(point);
    if (!items.isEmpty()) {
        int count(items.count());
        for (int current(0); current < count; ++current) {
            QGraphicsItem *item = items.at(current);
            hitItem = viewItem(item);
            if (hitItem && hitItem->modelIndex().isValid()) {
                ret = hitItem->modelIndex();
                break;
            }
        }
    }
    return ret;
}
/*!
    \reimp
*/
bool HbGridViewPrivate::visible(HbAbstractViewItem* item, bool fullyVisible) const
{
    if (item && item->isVisible()
        && item->modelIndex().isValid()) {
        return HbAbstractItemViewPrivate::visible(item, fullyVisible);
    }
    return false;
}


void HbGridViewPrivate::setIconVisible(bool iconVisible)
{
    if (iconVisible != mIconVisible) {
        mIconVisible = iconVisible;
        relayout();
    }
}

void HbGridViewPrivate::setTextVisible(bool textVisible)
{
    if (textVisible != mTextVisible) {
        mTextVisible = textVisible;
        relayout();
    }
}

void HbGridViewPrivate::relayout()
{
    QList<HbAbstractViewItem *> items = mContainer->items();
    foreach (HbAbstractViewItem *item, items) {
        HbGridViewItem *gridItem = qobject_cast<HbGridViewItem *>(item);
        if (gridItem) {
            gridItem->updateChildItems();
        }
    }
}

/*!
    Overwrites the default scroll area scrollbar updating algorithm when
    recycling is used. On recycling the scrollbar position & size is calculated
    using rows and their pixel size is not used.
*/
void HbGridViewPrivate::updateScrollBar(Qt::Orientation orientation)
{
    if (!mContainer->itemRecycling()
        || mContainer->itemPrototypes().count() != 1 
        || mContainer->items().count() == 0) {
        HbScrollAreaPrivate::updateScrollBar(orientation);
    } else {
        if (mContainer->layout() && !mContainer->layout()->isActivated()) {
            mContainer->layout()->activate();
        }
        if (orientation == Qt::Vertical) {
            updateVerticalScrollBar();
        } else {
            updateHorizontalScrollBar();
        }
    }
} 

void HbGridViewPrivate::updateHorizontalScrollBar()
{    
    Q_Q(const HbGridView);
    
    HbAbstractViewItem *firstItem = mContainer->items().first();
    qreal uniformItemWidth = firstItem->size().width();

    int rowCount = q->rowCount();
    int indexCount = mModelIterator->indexCount();

    int virtualColumnCount = indexCount / rowCount;
    int remainder = indexCount % rowCount;
    if (remainder != 0) {
        virtualColumnCount++;
    }

    int firstItemModelRowNumber = mModelIterator->indexPosition(firstItem->modelIndex());
    int firstBufferItemRowNumber = firstItemModelRowNumber / rowCount; 

    QRectF itemRect = itemBoundingRect(firstItem);
    qreal realLeftBoundary = itemRect.left();   
    qreal virtualLeftBoundary = realLeftBoundary - (firstBufferItemRowNumber*uniformItemWidth); 

    qreal containerVirtualWidth = uniformItemWidth *  virtualColumnCount;
    qreal thumbPosition(0);

    // The scrollbar "thumb" position is the current position of the contents widget divided
    // by the difference between the width of the contents widget and the width of the scroll area.
    // This formula assumes that the "thumb" of the the scroll bar is sized proportionately to
    // the width of the contents widget.
    qreal hiddenVirtualWidth = containerVirtualWidth - q->boundingRect().width();
    if (hiddenVirtualWidth != 0) {
        thumbPosition = (-virtualLeftBoundary)  / hiddenVirtualWidth;
    }

    if (thumbPosition < 0.0)
        thumbPosition = 0.0;
    else if (thumbPosition > 1.0)
        thumbPosition = 1.0;

    if (mHorizontalScrollBar) {
        if (containerVirtualWidth!=0) {
            mHorizontalScrollBar->setPageSize(qBound ( (qreal)0.0,
                                     q->boundingRect().width() / containerVirtualWidth,
                                      (qreal)1.0));
        }
        mHorizontalScrollBar->setValue(thumbPosition); 
    }
}

void HbGridViewPrivate::updateVerticalScrollBar()
{
    Q_Q(const HbGridView);

    HbAbstractViewItem *firstItem = mContainer->items().first();
    qreal uniformItemHeight = firstItem->size().height();

    int columnCount = q->columnCount();
    int indexCount = mModelIterator->indexCount();

    int virtualRowCount = indexCount / columnCount;
    int remainder = indexCount % columnCount;
    if (remainder != 0) {  //even one item requires the whole row
        virtualRowCount++;
    }

    int firstItemModelRowNumber = mModelIterator->indexPosition(firstItem->modelIndex());
    int firstBufferItemRowNumber = firstItemModelRowNumber / columnCount; 

    QRectF itemRect = itemBoundingRect(firstItem);
    qreal realTopBoundary = itemRect.top();
    qreal virtualTopBoundary = realTopBoundary - (firstBufferItemRowNumber*uniformItemHeight); 

    qreal containerVirtualHeight = uniformItemHeight *  virtualRowCount;
    qreal thumbPosition = 0;

    // The scrollbar "thumb" position is the current position of the contents widget divided
    // by the difference between the height of the contents widget and the height of the scroll area.
    // This formula assumes that the "thumb" of the the scroll bar is sized proportionately to
    // the height of the contents widget.
    qreal hiddenVirtualHeight = containerVirtualHeight - q->boundingRect().height();
    if (hiddenVirtualHeight != 0) {
        thumbPosition = (-virtualTopBoundary) / hiddenVirtualHeight;
    } 

    if (thumbPosition < 0.0)
        thumbPosition = 0.0;
    else if (thumbPosition > 1.0)
        thumbPosition = 1.0;

    if (mVerticalScrollBar) {
        if (containerVirtualHeight!=0) {
            mVerticalScrollBar->setPageSize(qBound ( (qreal)0.0,
                                     q->boundingRect().height() / containerVirtualHeight,
                                      (qreal)1.0));
        }
        mVerticalScrollBar->setValue(thumbPosition); 
    }    
}

void HbGridViewPrivate::setScrollBarMetrics(Qt::Orientation orientation)
{   
    if (!mContainer->itemRecycling()
        || mContainer->itemPrototypes().count() != 1 
        || mContainer->items().count() == 0)  {
        HbScrollAreaPrivate::setScrollBarMetrics(orientation);
    } else {
        //We just make sure that the base clas is not called
        //It set the page size wrongly
        updateScrollBar(orientation); 
    }
} 

void HbGridViewPrivate::setContentPosition( qreal value, Qt::Orientation orientation, bool animate )
{
    Q_Q( HbGridView );

    if (mContainer->itemRecycling() && mModelIterator->model()) {
        if (mContainer->layout() && !mContainer->layout()->isActivated()) {
            mContainer->layout()->activate();
        }

        qreal filteredValue = (int)(value * 1000) / 1000.0;        

        HbAbstractViewItem *firstItem = mContainer->items().first();

        qreal uniformItemDimension = 0; // width or height of item
        qreal dimension = 0; // width or height of view
        int dimensionCount = 0; // rowcount or columncount
        qreal posInBeginning = 0; // top or left position of first item in buffer

        if (orientation == Qt::Vertical) {
            posInBeginning = itemBoundingRect(firstItem).top();
            uniformItemDimension = firstItem->size().height();
            dimension = q->boundingRect().height();
            dimensionCount = q->columnCount();
        } else {
            posInBeginning = itemBoundingRect(firstItem).left();
            uniformItemDimension = firstItem->size().width();
            dimension = q->boundingRect().width();
            dimensionCount = q->rowCount();
        }

        int indexCount = mModelIterator->indexCount();
        int virtualCount = indexCount / dimensionCount; // amount of rows/columns in "complete" grid
        int remainder = indexCount % dimensionCount;
        if (remainder != 0) {  //even one item requires the whole row
            virtualCount++;
        }

        qreal target = virtualCount * filteredValue;  // target position in "complete" grid (in rows/columns)
        int virtualItemCount = virtualCount * dimensionCount; // item count when all the "empty" items are also counted in
        qreal posToBeInView = dimension * filteredValue; 

        QModelIndex newIndex = mModelIterator->index(qMin((int)(virtualItemCount * filteredValue), indexCount - 1));

        if (!mContainer->itemByIndex(newIndex)) {
            //jump
            int itemsInBuffer = mContainer->items().count();

            int newBufferStartItem = (int)(virtualItemCount * filteredValue) - qMin(itemsInBuffer - 1, (int)(itemsInBuffer * filteredValue));
            mContainer->setModelIndexes(mModelIterator->index(newBufferStartItem));
            int newBufferStartRow = newBufferStartItem / dimensionCount;

            qreal posToBeInBuffer = ((target - newBufferStartRow) * uniformItemDimension);

            qreal posToBe = posToBeInView - posToBeInBuffer;

            if (orientation == Qt::Vertical) {
                HbScrollAreaPrivate::setContentPosition(QPointF(0, posToBe)); 
            } else {
                HbScrollAreaPrivate::setContentPosition(QPointF(posToBe, 0)); 
            }
        } else {
            // scroll
            int firstItemRow = mContainer->items().first()->modelIndex().row() / dimensionCount;

            qreal posToBeInBuffer = (target - firstItemRow) * uniformItemDimension;
            
            qreal posToBe = posToBeInView - posToBeInBuffer;

            if (orientation == Qt::Vertical) {
                q->scrollByAmount(QPointF(0, posInBeginning - posToBe));
            } else {
                q->scrollByAmount(QPointF(posInBeginning - posToBe, 0));
            }
        }
    } else {
        HbScrollAreaPrivate::setContentPosition(value, orientation, animate);
    }
       
    if (animate) {
        updateScrollBar(orientation);
    }
}

QModelIndex HbGridViewPrivate::indexInTheCenter(Qt::Orientations scrollDirection) const
{
    Q_Q(const HbGridView);
    QModelIndex centerViewModelIndex; // nearest to center of the screen
    if (!mContainer->items().isEmpty()) {
        qreal centerPos;
        HbGridItemContainer *container = itemContainer();
        if (scrollDirection == Qt::Vertical) {
            // calculating row:
            centerPos = -container->pos().y() + q->boundingRect().height() / 2
                        // take rather item that is just above of view center instead of bottom one
                        - container->viewLayout()->effectiveSizeHint(Qt::MinimumSize).height() / 2;
            // calculate item row
            centerPos /= container->viewLayout()->effectiveSizeHint(Qt::MinimumSize).height();
            //calculate item index
            centerPos *= itemContainer()->columnCount();
            // go to center column
            centerPos += itemContainer()->columnCount() / 2;
        } else {
            // calculating row:
            centerPos = -container->pos().x() + q->boundingRect().width() / 2
                        // take rather item that is just on the left of view center instead of right one
                        - container->viewLayout()->effectiveSizeHint(Qt::MinimumSize).width() / 2;
            // calculate buffer row
            centerPos /= container->viewLayout()->effectiveSizeHint(Qt::MinimumSize).width();
            //calculate item index
            centerPos *= itemContainer()->rowCount();
            // go to center row
            centerPos += itemContainer()->rowCount() / 2;
        }
        int centerIndex = qRound(centerPos);
        if (centerIndex >= container->items().size()) {
            centerIndex = container->items().size() / 2;
        }
        centerViewModelIndex = container->items().at(centerIndex)->modelIndex();
    }
    return centerViewModelIndex;
}