/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*  Version     : %version: 14 %

*/

#include <QList>

#include <QAbstractItemModel>

#include <hgwidgets/hgcacheproxymodel.h>

#include <hgwidgets/hgdataprovidermodel.h>

#include "hgbuffermanager.h"

#include "hglogger.h"

HgCacheProxyModel::HgCacheProxyModel(QObject *parent):

    QAbstractItemModel(parent),

    mBufferManager(0),

    mSortFilterProxyModel(new QSortFilterProxyModel(this)),

    mDataProviderModel(0),

    mSupressBM(false),

    mCurrentPos(0)

{

    TX_ENTRY

    connect(mSortFilterProxyModel, SIGNAL(columnsAboutToBeInserted(const QModelIndex&, int, int)),

            this, SLOT(sourceColumnsAboutToBeInserted(const QModelIndex&, int, int)));

    connect(mSortFilterProxyModel, SIGNAL(columnsAboutToBeMoved(const QModelIndex&, int, int, const QModelIndex&, int)),

            this, SLOT(sourceColumnsAboutToBeMoved(const QModelIndex&, int, int, const QModelIndex&, int)));

    connect(mSortFilterProxyModel, SIGNAL(columnsAboutToBeRemoved(const QModelIndex&, int, int)),

            this, SLOT(sourceColumnsAboutToBeRemoved(const QModelIndex&, int, int)));

    connect(mSortFilterProxyModel, SIGNAL(columnsInserted(const QModelIndex&, int, int)),

            this, SLOT(sourceColumnsInserted(const QModelIndex&, int, int)));

    connect(mSortFilterProxyModel, SIGNAL(columnsMoved(const QModelIndex&, int, int, const QModelIndex&, int)),

            this, SLOT(sourceColumnsMoved(const QModelIndex&, int, int, const QModelIndex&, int)));

    connect(mSortFilterProxyModel, SIGNAL(columnsRemoved(const QModelIndex&, int, int )),

            this, SLOT(sourceColumnsRemoved(const QModelIndex&, int, int )));

    connect(mSortFilterProxyModel, SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),

            this, SLOT(sourceDataChanged(const QModelIndex&, const QModelIndex&)));

    connect(mSortFilterProxyModel, SIGNAL(headerDataChanged(Qt::Orientation, int, int)),

            this, SLOT(sourceHeaderDataChanged(Qt::Orientation, int, int)));

    connect(mSortFilterProxyModel, SIGNAL(layoutAboutToBeChanged()),

            this, SLOT(sourceLayoutAboutToBeChanged()));

    connect(mSortFilterProxyModel, SIGNAL(layoutChanged()),

            this, SLOT(sourceLayoutChanged()));

    connect(mSortFilterProxyModel, SIGNAL(modelAboutToBeReset()),

            this, SLOT(sourceModelAboutToBeReset()));

    connect(mSortFilterProxyModel, SIGNAL(modelReset()),

            this, SLOT(sourceModelReset()));

    connect(mSortFilterProxyModel, SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)),

            this, SLOT(sourceRowsAboutToBeInserted(const QModelIndex&, int, int)));

    connect(mSortFilterProxyModel, SIGNAL(rowsAboutToBeMoved(const QModelIndex&, int, int, const QModelIndex&, int)),

            this, SLOT(sourceRowsAboutToBeMoved(const QModelIndex&, int, int, const QModelIndex&, int)));

    connect(mSortFilterProxyModel, SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)),

            this, SLOT(sourceRowsAboutToBeRemoved(const QModelIndex&, int, int)));

    connect(mSortFilterProxyModel, SIGNAL(rowsInserted(const QModelIndex &, int , int)),

            this, SLOT(sourceRowsInserted(const QModelIndex &, int , int)));

    connect(mSortFilterProxyModel, SIGNAL(rowsMoved(const QModelIndex &, int, int, const QModelIndex&, int)),

            this, SLOT(sourceRowsMoved(const QModelIndex &, int, int, const QModelIndex&, int)));

    connect(mSortFilterProxyModel, SIGNAL(rowsRemoved(const QModelIndex&, int, int)),

            this, SLOT(sourceRowsRemoved(const QModelIndex&, int, int)));

    TX_EXIT

}

HgCacheProxyModel::~HgCacheProxyModel()

{

    TX_ENTRY

    delete mBufferManager;

    TX_EXIT    

}

void HgCacheProxyModel::setDataProvider(HgDataProviderModel *dataProvider, int cacheSize, int cacheTreshold)

{

    TX_ENTRY

    mDataProviderModel = dataProvider;

    mSortFilterProxyModel->setSourceModel(mDataProviderModel);

    if (mDataProviderModel) {

        mDataProviderModel->registerObserver(this);

        mSupressBM = true;

        resizeCache(cacheSize, cacheTreshold);

        mSupressBM = false;

        if (mBufferManager == NULL) {

            mBufferManager = new HgBufferManager(this, cacheSize, cacheTreshold, 0, count() );

        } else {

            mBufferManager->resetBuffer(0, count());

        }

    }

    TX_EXIT    

}

HgDataProviderModel* HgCacheProxyModel::DataProvider()

{

    return mDataProviderModel;

}

void HgCacheProxyModel::resizeCache(int newSize, int newTreshold)

{

    TX_ENTRY

    if (mDataProviderModel)

        mDataProviderModel->resizeQPixmapPool(newSize);

    if (mBufferManager)

        mBufferManager->resizeCache( newSize, newTreshold );

    TX_EXIT    

}

QModelIndex HgCacheProxyModel::index(int row, int column, const QModelIndex &parent) const

{

    Q_UNUSED(parent);

    if (row >= rowCount()) {

        row = -1;

    }

    if (column >= columnCount()) {

        column = -1;

    }

    return QAbstractItemModel::createIndex(row, column); 

}

QModelIndex HgCacheProxyModel::parent(const QModelIndex &child) const

{

    return mSortFilterProxyModel->parent(mapToSource(child));

}

int HgCacheProxyModel::rowCount(const QModelIndex &parent) const

{

    return mSortFilterProxyModel->rowCount(mapToSource(parent));

}

int HgCacheProxyModel::columnCount(const QModelIndex &parent) const

{

    return mSortFilterProxyModel->columnCount(mapToSource(parent));

}

bool HgCacheProxyModel::hasChildren(const QModelIndex &parent) const

{

    return mSortFilterProxyModel->hasChildren(mapToSource(parent));

}

QVariant HgCacheProxyModel::data(const QModelIndex &index, int role) const

{    

    setBufferPosition(index.row());

    QVariant res = mSortFilterProxyModel->data(mapToSource(index), role);

    return res;

}

bool HgCacheProxyModel::setData(const QModelIndex &index, const QVariant &value, int role)

{

    return mSortFilterProxyModel->setData(mapToSource(index), value, role);

}

QVariant HgCacheProxyModel::headerData(int section, Qt::Orientation orientation, int role) const

{

    return mSortFilterProxyModel->headerData(section, orientation, role);

}

bool HgCacheProxyModel::setHeaderData(int section, Qt::Orientation orientation, const QVariant &value, int role)

{

    return mSortFilterProxyModel->setHeaderData(section, orientation, value, role);

}

QMap<int, QVariant> HgCacheProxyModel::itemData(const QModelIndex &index) const

{

    setBufferPosition(index.row());

    return mSortFilterProxyModel->itemData(mapToSource(index));

}

bool HgCacheProxyModel::setItemData(const QModelIndex &index, const QMap<int, QVariant> &roles)

{

    return mSortFilterProxyModel->setItemData(mapToSource(index), roles);

}

QStringList HgCacheProxyModel::mimeTypes() const

{

    return mSortFilterProxyModel->mimeTypes();

}

QMimeData *HgCacheProxyModel::mimeData(const QModelIndexList &indexes) const

{

    QModelIndexList list;

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

        list.append(mapToSource(indexes[i]));

    }

    return mSortFilterProxyModel->mimeData(list);

}

bool HgCacheProxyModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent)

{

    return mSortFilterProxyModel->dropMimeData(data, action, row, column, mapToSource(parent));

}

Qt::DropActions HgCacheProxyModel::supportedDropActions() const

{

    return mSortFilterProxyModel->supportedDropActions();

}

bool HgCacheProxyModel::insertRows(int row, int count, const QModelIndex &parent)

{

    return mSortFilterProxyModel->insertRows(row, count, mapToSource(parent));

}

bool HgCacheProxyModel::insertColumns(int column, int count, const QModelIndex &parent)

{

    return mSortFilterProxyModel->insertColumns(column, count, mapToSource(parent));

}

bool HgCacheProxyModel::removeRows(int row, int count, const QModelIndex &parent)

{

    return mSortFilterProxyModel->removeRows(row, count, mapToSource(parent));

}

bool HgCacheProxyModel::removeColumns(int column, int count, const QModelIndex &parent)

{

    return mSortFilterProxyModel->removeColumns(column, count, mapToSource(parent));

}

void HgCacheProxyModel::fetchMore(const QModelIndex &parent)

{

    mSortFilterProxyModel->fetchMore(mapToSource(parent));

}

bool HgCacheProxyModel::canFetchMore(const QModelIndex &parent) const

{

    return mSortFilterProxyModel->canFetchMore(mapToSource(parent));

}        

Qt::ItemFlags HgCacheProxyModel::flags(const QModelIndex &index) const

{

    return mSortFilterProxyModel->flags(mapToSource(index));

}

void HgCacheProxyModel::sort(int column, Qt::SortOrder order)

{

    mSupressBM = true;

    sourceModelAboutToBeReset();

    mSortFilterProxyModel->sort(column, order);

    sourceModelReset();  

}

QModelIndex HgCacheProxyModel::buddy(const QModelIndex &index) const

{

    return mSortFilterProxyModel->buddy(mapToSource(index));

}

QModelIndexList HgCacheProxyModel::match(const QModelIndex &start, int role,

                              const QVariant &value, int hits,

                              Qt::MatchFlags flags) const

{

    return mSortFilterProxyModel->match(mapToSource(start), role, value, hits, flags);

}

QSize HgCacheProxyModel::span(const QModelIndex &index) const

{

    return mSortFilterProxyModel->span(mapToSource(index));

}

Qt::CaseSensitivity HgCacheProxyModel::sortCaseSensitivity() const

{

    return mSortFilterProxyModel->sortCaseSensitivity();

}

void HgCacheProxyModel::setSortCaseSensitivity(Qt::CaseSensitivity cs)

{

    if (sortCaseSensitivity() != cs) {

        mSupressBM = true;

        sourceModelAboutToBeReset();

        mSortFilterProxyModel->setSortCaseSensitivity(cs);

        sourceModelReset();  

    }

}

bool HgCacheProxyModel::isSortLocaleAware() const

{

    return mSortFilterProxyModel->isSortLocaleAware();

}

void HgCacheProxyModel::setSortLocaleAware(bool on)

{

    if (isSortLocaleAware() != on) {

        mSupressBM = true;    

        sourceModelAboutToBeReset();

        mSortFilterProxyModel->setSortLocaleAware(on);

        sourceModelReset();  

    }

}

int HgCacheProxyModel::sortColumn() const

{

    return mSortFilterProxyModel->sortColumn();

}

Qt::SortOrder HgCacheProxyModel::sortOrder() const

{

    return mSortFilterProxyModel->sortOrder();

}

bool HgCacheProxyModel::dynamicSortFilter() const

{

    return mSortFilterProxyModel->dynamicSortFilter();

}

void HgCacheProxyModel::setDynamicSortFilter(bool enable)

{

    if (dynamicSortFilter() != enable) {

        mSupressBM = true;   

        sourceModelAboutToBeReset();

        mSortFilterProxyModel->setDynamicSortFilter(enable);

        sourceModelReset();  

    }

}

int HgCacheProxyModel::sortRole() const

{

    return mSortFilterProxyModel->sortRole();

}

void HgCacheProxyModel::setSortRole(int role)

{

    if (sortRole() != role) {

        mSupressBM = true;

        sourceModelAboutToBeReset();

        mSortFilterProxyModel->setSortRole(role);

        sourceModelReset();    

    }

}

QRegExp HgCacheProxyModel::filterRegExp() const

{

    return mSortFilterProxyModel->filterRegExp();

}

void HgCacheProxyModel::setFilterRegExp(const QRegExp &regExp)

{

    if (filterRegExp() != regExp) {

        mSupressBM = true;

        sourceModelAboutToBeReset();

        mSortFilterProxyModel->setFilterRegExp(regExp);

        sourceModelReset();    

    }

}

int HgCacheProxyModel::filterKeyColumn() const

{

    return mSortFilterProxyModel->filterKeyColumn();

}

void HgCacheProxyModel::setFilterKeyColumn(int column)

{

    if (filterKeyColumn() != column) {

        mSupressBM = true;

        sourceModelAboutToBeReset();

        mSortFilterProxyModel->setFilterKeyColumn(column);

        sourceModelReset();    

    }

}

Qt::CaseSensitivity HgCacheProxyModel::filterCaseSensitivity() const

{

    return mSortFilterProxyModel->filterCaseSensitivity();

}

void HgCacheProxyModel::setFilterCaseSensitivity(Qt::CaseSensitivity cs)

{

    if (filterCaseSensitivity() != cs) {   

        mSupressBM = true;

        sourceModelAboutToBeReset();

        mSortFilterProxyModel->setFilterCaseSensitivity(cs);

        sourceModelReset();    

    }

}

int HgCacheProxyModel::filterRole() const

{

    return mSortFilterProxyModel->filterRole();

}

void HgCacheProxyModel::setFilterRole(int role)

{

    if (filterRole() != role) {

        mSupressBM = true;

        sourceModelAboutToBeReset();

        mSortFilterProxyModel->setFilterRole(role);

        sourceModelReset();    

    }

}

bool HgCacheProxyModel::submit()

{

    return mSortFilterProxyModel->submit();

}

void HgCacheProxyModel::revert()

{

    mSortFilterProxyModel->revert();

}

void HgCacheProxyModel::release(int start, int end)

{

    TX_ENTRY_ARGS( QString("%0-%1").arg(start).arg(end));   

    QList<int> list;

    int idx = 0;

    if (start > end) {

        idx = end;

        end = start;

        start = idx;

        idx = 0;

    }

    for (int i=start; i <=end; i++) {

        idx = mapToDataProviderIndex(i);

        if (idx >=0)

            list.append(idx);

    }

    if (mDataProviderModel) {

        mSupressBM = true;

        mDataProviderModel->release(list, false);

        mSupressBM = false;

    }

    TX_EXIT

}

void HgCacheProxyModel::request(int start, int end, HgRequestOrder order)

{

    TX_ENTRY_ARGS( QString("%0-%1").arg(start).arg(end));   

    QList<int> list;

    int idx;

    if (order == HgRequestOrderAscending) {

        for (int i=start; i <=end; i++) {

            idx = mapToDataProviderIndex(i);

            if (idx >=0)

                list.append(idx);

        }

    } else {

        for (int i=end; i >=start; i--) {

            idx = mapToDataProviderIndex(i);

            if (idx >=0)

                list.append(idx);

        }

    }

    if (mDataProviderModel && list.count()>0)

        mDataProviderModel->request(list, mSupressBM);

    TX_EXIT    

}

int HgCacheProxyModel::count()const

{

    return rowCount(index(0, 0, QModelIndex()));

}

QModelIndex HgCacheProxyModel::mapToSource(const QModelIndex &index) const

{

    return mapToSource(index.row(), index.column());

}

QModelIndex HgCacheProxyModel::mapToSource(int row, int col) const

{

    return mSortFilterProxyModel->index(row, col);

}

int HgCacheProxyModel::mapToDataProviderIndex(int myIndex) const

{

    return mSortFilterProxyModel->mapToSource( mapToSource(myIndex, 0)).row();

}

int HgCacheProxyModel::mapFromDataProviderIndex(int myIndex) const

{

    return mSortFilterProxyModel->mapFromSource( mDataProviderModel->index(myIndex, 0) ).row();

}

void HgCacheProxyModel::releaseAll()

{

    if (mDataProviderModel) {

        QList<int> list;

        for (int i=0; i<mDataProviderModel->rowCount(); i++) {

            list.append(i);

        }

        mDataProviderModel->release(list, true);

    }

}

void HgCacheProxyModel::setBufferPosition(int pos) const

{

    if (mBufferManager && !mSupressBM) {

        if (mCurrentPos!=pos) {