/*

* 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: 18 %

*/

#include <e32debug.h>

#include <QVariant>

#include <HbIcon>

#include <qpixmapdata_p.h>

#include <hgwidgets/hgdataprovidermodel.h>

#include <hgwidgets/hgcacheproxymodel.h>

#include "hglogger.h"

const int KQPixmapCacheEmergencyBuffer = 5;

HgDataProviderModel::HgDataProviderModel(QObject *parent) : 

    QAbstractItemModel(parent),

    mCache(new QList<QMap<int, QVariant>*>()),

    mCacheSize(0),

    mUnallocatedPixmaps(0),

    mObserver(0),

    mIconMode(HgDataProviderIconHbIcon)

{

    TX_ENTRY

    TX_EXIT

}

HgDataProviderModel::~HgDataProviderModel()

{

    TX_ENTRY    

    clearCache();

    delete mCache;

    qDeleteAll(mFreePixmaps.begin(), mFreePixmaps.end());

    mFreePixmaps.clear();

    qDeleteAll(mUsedPixmaps.begin(), mUsedPixmaps.end());

    mUsedPixmaps.clear();

    TX_EXIT

}

void HgDataProviderModel::release(QList<int> list, bool silent)

{

    TX_ENTRY    

    int i=0;

    int min = count();

    int max = 0;

    bool correct = false;

    for (int idx = 0; idx < list.count(); idx++) {

        i = list[idx];

        if (i >=0 && i<count()) {

            if (i < min) {

                min = i;

            }

            if (i > max) {

                max = i;

            }

            resetIcon(i);

            correct = true;

        }

    }

    doReleaseData(list, silent);

    if (correct) {

        emitDataChanged(min, max, silent);

    }

    TX_EXIT

}

void HgDataProviderModel::request(QList<int> list, bool silent)

{

    TX_ENTRY

    doRequestData(list, silent); 

    TX_EXIT    

}

void HgDataProviderModel::registerObserver(HgDataProviderModelObserver* obs)

{

    TX_ENTRY

    mObserver = obs;

    TX_EXIT    

}

QModelIndex HgDataProviderModel::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 HgDataProviderModel::parent(const QModelIndex &child) const

{

    Q_UNUSED(child);

    return QModelIndex();   //returns always invalid model index

}

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

{

    Q_UNUSED(parent);

    return count();

}

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

{

    Q_UNUSED(parent);

    return 1;

}

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

{

    return data(index.row(), role);

}

QVariant HgDataProviderModel::data(int idx, int role) const

{

    QVariant res;

    if (containsRole(idx, role)) {

        res = mCache->at(idx)->value(role);

    } else if (isIndexValid(idx)) {

        if (role == Qt::DecorationRole) {

            res = defaultIcon();

        } else {

            res = getData(idx, role);

        }

    }

    return res;

}

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

{

    QMap<int, QVariant> res;

    if (index.row()>=0 && index.row()<count()) {

        res = QMap<int, QVariant>(*mCache->at(index.row()));

    }   

    return res;

}

void HgDataProviderModel::clearCache()

{

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

        releasePixmap(i);

    }

    qDeleteAll(mCache->begin(), mCache->end());

    mCache->clear();

}

int HgDataProviderModel::count() const

{

    return mCache->count();

}

bool HgDataProviderModel::update(int pos, QList< QPair< QVariant, int > >* list, bool silent)

{

    bool change(false);

    if (list && list->count() && isIndexValid(pos)) {

        while(list->count()>0) {

            QPair< QVariant, int > pair = list->takeFirst();

            change = update(pos, pair.first, pair.second, true)|change;

        }

        if (!silent && change) {

            emitDataChanged(pos, pos, false);

        }

    }

    return change;

}

bool HgDataProviderModel::update(int pos, QVariant obj, int role, bool silent)

{

    bool change(false);

    if (isIndexValid(pos)) {

        mDataLock.lock();

        mCache->at(pos)->insert(role, obj); //this will remove old one if needed

        mDataLock.unlock();        

        change = true;

    }

    if (!silent && change) {

        emitDataChanged(pos, pos, false);

    }

    return change;

}

bool HgDataProviderModel::updateIcon(int pos, QVariant obj, bool silent)

{

    bool change(false);

    if (obj.isValid() && !obj.isNull() && isIndexValid(pos)) {

        mDataLock.lock();

        mCache->at(pos)->insert(Qt::DecorationRole, obj); //will remove old if needed

        mDataLock.unlock();        

        change = true;

        if (!silent) {

            TX_LOG_ARGS(QString("pos:%1").arg( pos ) );

            if (mObserver) {

                mObserver->dataUpdated(pos,pos);

            } else { //if no observer, let's emit signal

                QModelIndex topLeft = index(pos, 0);

                QModelIndex bottomRight = index(pos, 0);

                emit dataChanged(topLeft, bottomRight);

            }

        }

    }

    return change;

}

void HgDataProviderModel::resetIcon(int pos)

{

    if (containsRole(pos, Qt::DecorationRole)) {

        mCache->at(pos)->remove(Qt::DecorationRole);

    }

}

void HgDataProviderModel::newItem(QList< QPair< QVariant, int > >* list, bool silent)

{

    insertItem(mCache->count(), list, silent);

}

void HgDataProviderModel::newItem(QPair< QVariant, int > item, bool silent)

{

    insertItem(mCache->count(), item, silent);

}

void HgDataProviderModel::insertItem(int pos, QList< QPair< QVariant, int > >* list, bool silent)

{

    doInsertItem(pos, list, silent);

}

void HgDataProviderModel::insertItem(int pos, QPair< QVariant, int > item, bool silent)

{

    QList< QPair< QVariant, int > > list;

    list.append(item);

    doInsertItem(pos, &list, silent);

}

void HgDataProviderModel::clearItem(int pos, bool silent)

{

    bool change = false;

    if (isIndexValid(pos)) {

        mDataLock.lock();    

        mCache->at(pos)->clear();

        mDataLock.unlock();

        change = true;

    }

    if (change && !silent) {

        emit dataChanged( index(pos, 0), index(pos, 0) );

    }

}

void HgDataProviderModel::doInsertItem(int pos, QList< QPair< QVariant, int > >* list, bool silent)

{

    if (pos >mCache->count() || pos <0) {

        return;

    }

    if (!silent) {

        beginInsertRows(QModelIndex(), pos, pos);

    }

    mDataLock.lock();    

    mCache->insert(pos, new QMap<int, QVariant>());

    mDataLock.unlock();

    if (list && list->count()) {

        update(pos, list, true);

    }

    if (!silent) {

        endInsertRows();

    } 

}

void HgDataProviderModel::removeItem(int pos, bool silent)

{

    removeItems(pos, 1, silent);

}

void HgDataProviderModel::removeItems(int pos, int size, bool silent)

{

    if (pos >=mCache->count()) {

        return;

    } else if (pos <0) {

        size = size + pos; //pos <0

        pos = 0;

    }

    if (size >mCache->count()) {

        size = mCache->count();

    }

    if (size <=0) {

        return;

    }

    if (!silent) {

        beginRemoveRows(QModelIndex(),pos, pos+size-1);

    } else {

        qWarning("Removing items without notifying might be danger.");

    }

    mDataLock.lock();

    for (int i=0; i<size && pos<mCache->count(); i++) {

        mCache->removeAt(pos);

    }

    mDataLock.unlock();

    if (!silent)

        endRemoveRows();

}

void HgDataProviderModel::resetModel() 

{

    beginResetModel();

    doResetModel();

    endResetModel();

}

void HgDataProviderModel::setIconMode(HgDataProviderModel::HgDataProviderIconMode mode)

{

    mIconMode = mode;

}

HgDataProviderModel::HgDataProviderIconMode HgDataProviderModel::iconMode()

{

    return mIconMode;

}

void HgDataProviderModel::emitDataChanged(int from, int to, bool silent)

{

    if (!silent) {

//        TX_LOG

        QModelIndex topLeft = index(from, 0);

        QModelIndex bottomRight = index(to, 0);

        emit dataChanged(topLeft, bottomRight);

    }

}

void HgDataProviderModel::resizeQPixmapPool(int newSize)

{

    mQPixmapsLock.lock();

    int currentSize = mFreePixmaps.count() + mUsedPixmaps.count();

    int diff = currentSize - newSize - KQPixmapCacheEmergencyBuffer;

    mUnallocatedPixmaps = 0;

    while (diff != 0) {

        if (diff < 0) {

            mUnallocatedPixmaps++;

            diff++;

        } else {

            if (mUnallocatedPixmaps>0) {

                mUnallocatedPixmaps--;

            } else if (mFreePixmaps.count()) {

                mFreePixmaps.removeLast();

            } //else will be deleted with releasePixmap;

            diff--;

        }

    }

    mQPixmapsLock.unlock();

    mCacheSize = newSize;

}

void HgDataProviderModel::releasePixmap(int idx)

{

    mQPixmapsLock.lock();

    if (mUsedPixmaps.contains(idx)) {

        QPixmap* pix = mUsedPixmaps.take(idx);

        if ((mFreePixmaps.count() + mUsedPixmaps.count() + mUnallocatedPixmaps ) >= ( mCacheSize + KQPixmapCacheEmergencyBuffer)) {

            delete pix; //we have too many pixmaps

        } else {

            mFreePixmaps.append(pix);

        }

    } else {

//        TX_LOG_ARGS( QString("can't release pixmap for idx=%0").arg(idx));

    }

    mQPixmapsLock.unlock();    

}

QVariant HgDataProviderModel::createIcon(int index, QPixmap aPixmap)

{

    TX_ENTRY

    QVariant res;

	QPixmap* pix = getPixmap(index);

	if (pix) {

		if (pix->pixmapData()) {

			pix->pixmapData()->fromImage(aPixmap.toImage(), Qt::AutoColor );  

		} else {

			*pix = aPixmap;

		}

		mQPixmapsLock.lock();

		mUsedPixmaps.insert(index, pix);

		mQPixmapsLock.unlock();

		switch (mIconMode) {

            case HgDataProviderIconHbIcon : 

                res = HbIcon(QIcon(*pix));  

                break;

		    case HgDataProviderIconQIcon : 

                res = QIcon(*pix);

                break;

		    case HgDataProviderIconQImage : 

                res = pix->toImage();

                break;

		    case HgDataProviderIconQPixmap:		    

		        res = *pix;  

		        break;

            default:

                break;

		}

	}

	if (res.isNull()) {

	    TX_EXIT_ARGS( QString("No pixmap avilable"));

	}

	return res;

}

QPixmap* HgDataProviderModel::getPixmap(int idx)

{

//    TX_ENTRY

    QPixmap* res = NULL;

    mQPixmapsLock.lock();

    if (mUsedPixmaps.contains(idx)) {

        res = mUsedPixmaps.take(idx);//let's just replace pixmapdata for that pixmap

    } else {

        if (!mFreePixmaps.isEmpty()) {

            res = mFreePixmaps.takeFirst();

        }else if (mUnallocatedPixmaps) {

            mUnallocatedPixmaps--;

            res = new QPixmap();

        } else {

            TX_LOG_ARGS(QString("no free pixmaps"));

        }

    }

    mQPixmapsLock.unlock();

//    TX_EXIT

    return res;

}

//eof