/*

* Copyright (c) 2010 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: Class for asynchronously fetching and caching basic

*              contact info (see CntContactInfo) for list views.

*

*/

#include <hbapplication.h>

#include <qtcontacts.h>

#include <qcontactmanager.h>

#include <cntdebug.h>

#include "cntcache.h"

#include "cntcache_p.h"

// set the singleton instance pointer to NULL

CntCache* CntCache::mInstance = NULL;

// value for first cache order to be assigned

static const int CacheOrderStartValue = 1;

// for avoiding wrap around with cache orders

static const int MaxCacheOrderValue = 10000000;

// number of items to read quickly when a new instance is requested or cache is cleared

// number of items to read ahead into cache; this number is for one direction

static const int ItemsToCacheAhead = 24;

// cache size for info items (name, text, icon1name, icon2name)

static const int InfoCacheSize = 128;

// cache size for icon items (iconName and HbIcon)

static const int IconCacheSize = 50;

// number of icons in a CntContactInfo object

static const int IconsInCntContactInfo = 2;

// default empty text info field for a contact; it cannot be empty

// as the listview will then ignore it, causing rendering problems

static const QString EmptyTextField = " ";

/*!

    Provides a pointer to the CntCache singleton instance.

 */

{

    }

    // whenever a client requests an instance the client will want to get all info

    // for the first couple of contacts (~a screenfull) as fast as possible

    mInstance->mUrgentContacts = ItemsToReadUrgently;

    return mInstance;

}

/*! 

    Fetches information about a contact: name, text (e.g. phone number or

    social status) and two icons (e.g. avatar, presence). Previously cached

    content - at the very least the name - will be returned immediately.

    Availability of more information will be checked asynchronously and

    sent to clients via contactInfoUpdated() signals.

    The function takes a row and a list rather than just a contact id because

    of read ahead caching - contacts near the requested contacts are expected

    to be needed soon and are therefore also scheduled for caching.

    \param row the row of the contact to fetch

    \param idList a list with all the IDs in the list

    \return a contact with some details filled in

 */

CntContactInfo CntCache::fetchContactInfo(int row, const QList<QContactLocalId>& idList)

{

    CNT_ENTRY_ARGS(row << "/" << idList.count())

    Q_ASSERT(row >= 0 && row < idList.count());

    QString name;

    QString text = EmptyTextField;

    HbIcon icons[IconsInCntContactInfo];

    int contactId = idList.at(row);

    if (contactId != mEmittedContactId) {

        // this request comes from the UI when a new view is created or in response to

        // some scrolling activity; in the former case, the client should

        // have set urgencymode on, but in the latter case:

        // 1) postpone all jobs so the UI can use as much of the CPU as possible

        // 2) update read ahead cache to contain all IDs of all items near this item

        if (mUrgentContacts > 0) {

            --mUrgentContacts;

        }

        updateReadAheadCache(row, idList);

    }

    // fetch contact

    if (mInfoCache.contains(contactId)) {

        // the item is in the cache

        CntInfoCacheItem* infoItem = mInfoCache.value(contactId);

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

            QString iconName = infoItem->icons[i];

            if (!iconName.isEmpty()) {

                if (mIconCache.contains(iconName)) {

                    CntIconCacheItem* iconItem = mIconCache.value(iconName);

                    iconItem->cacheOrder = mNextIconCacheOrder++;

                    icons[i] = iconItem->icon;

                    if (!iconItem->isFetched) {

                        // if icon has not yet been received from backend, add

                        // this id to the list of contacts that want to be

                        // notified when the icon is received

                        iconItem->contactIds.insert(contactId);

                        // also reschedule it

                        mWorker->scheduleIconJob(iconName, row);

                    }

                    // needed icon is not in cache, so schedule it for retrieval

                    CntIconCacheItem* iconItem = createIconCacheItem(iconName);

                    iconItem->contactIds.insert(contactId);

                    mWorker->scheduleIconJob(iconName, row);

                }

            }

        }

        // update cache order

        infoItem->cacheOrder = mNextInfoCacheOrder++;

        infoItem->latestRow = row;

            // contact found, so add new entry to cache

            CntInfoCacheItem* item = createInfoCacheItem(contactId);

            item->text = text;

            item->latestRow = row;

            // ask the worker thread to fetch the information asynchronously

            mWorker->scheduleInfoJob(contactId, row);

        }

    }

    CNT_EXIT_ARGS("name:" << name << "sec:" << text)

    return CntContactInfo(contactId, name, text, icons[0], icons[1]);

}

/*! 

 */

{

    CNT_ENTRY

    qDeleteAll(mInfoCache);

    mInfoCache.clear();

    CNT_EXIT

}

/*! 

    Processes a new info field that has arrived from the worker thread.

    If the contact is in the info cache, then the info cache is updated

    accordingly.

    A contactInfoUpdated() signal is usually also emitted. The exception

    is if the info is the name of an icon and that icon is not in the icon

    cache. In this case the icon is fetched before a signal is emitted.

 */

void CntCache::onNewInfo(int contactId, const ContactInfoField& infoField, const QString& infoValue)

{

    CNT_ENTRY_ARGS( "id:" << contactId   << "infotype:" << infoField   << "infovalue:" << infoValue )

    Q_ASSERT(infoField == ContactInfoTextField || infoField == ContactInfoIcon1Field || infoField == ContactInfoIcon2Field);

    bool hasNewInfo;

    if (!mInfoCache.contains(contactId)) {

        // contact is not in cache, so nothing needs to be done

        // except notify clients that this contact has (possibly)

        // been changed

        hasNewInfo = true;

    }

    else if (infoField == ContactInfoTextField) {

        // update cache with new text for contact

        mInfoCache.value(contactId)->text = infoValue;

        hasNewInfo = true;

    }

    else {

        // update cache with new icon name for contact

        int iconIndex = (infoField == ContactInfoIcon1Field ? 0 : 1);

        CntInfoCacheItem* item = mInfoCache.value(contactId);

        QString iconName = infoValue;

        if (item->icons[iconIndex] != iconName) {

            item->icons[iconIndex] = iconName;

            if (iconName.isEmpty()) {

                hasNewInfo = true;

            }

            else if (mIconCache.contains(iconName)) {

                CntIconCacheItem* iconItem = mIconCache.value(iconName);

                if (!iconItem->isFetched) {

                    iconItem->contactIds.insert(contactId);

                    hasNewInfo = false;

                }

                else {

                    hasNewInfo = true;

                }

            }

            else if (iconName.startsWith("qtg_", Qt::CaseInsensitive)) {

                createIconCacheItem(iconName);

                onNewIcon(iconName, HbIcon(iconName)); 

                hasNewInfo = true;

            }

            else {

                CntIconCacheItem* iconItem = createIconCacheItem(iconName);

                iconItem->contactIds.insert(contactId);

				if (mInfoCache.contains(contactId)) {

                	mWorker->scheduleIconJob(iconName, mInfoCache.value(contactId)->latestRow);

				}

				else {

					// less important icon, since this contact is not in cache

                	mWorker->scheduleIconJob(iconName, 100000);

				}

                hasNewInfo = false;

            }

        }

        else {

            hasNewInfo = false;

        }

    }

    if (hasNewInfo) {

        emitContactInfoUpdated(contactId);

    }

    CNT_EXIT

}

/*! 

    Handle the case where a request for contact info is cancelled by the

    worker because of too many subsequent requests.

 */

void CntCache::onInfoCancelled(int contactId)

{

    CNT_ENTRY_ARGS( "id:" << contactId )

    if (mInfoCache.contains(contactId)) {

        CntInfoCacheItem* item = mInfoCache.take(contactId);

        delete item;

    }

    emitContactInfoUpdated(contactId);

    CNT_EXIT

}

/*! 

    Processes a new icon that has arrived from the worker thread.

    The icon cache is updated and a contactInfoUpdated() signal is

    emitted for all contacts that use this icon.

 */

void CntCache::onNewIcon(const QString& iconName, const HbIcon& icon)

{

    CNT_ENTRY_ARGS( iconName )

    QSet<int> contactsToNotify;

    if (mIconCache.contains(iconName)) {

        CntIconCacheItem* item = mIconCache.value(iconName);

        item->icon = icon;

        item->isFetched = true;

        contactsToNotify = item->contactIds;

        item->contactIds.clear();

    }

    foreach (int contactId, contactsToNotify) {

        emitContactInfoUpdated(contactId);

    }

    CNT_EXIT

}

/*! 

    Handle the case where a request for an icon is cancelled by the worker because

    of too many subsequent requests.

 */

void CntCache::onIconCancelled(const QString& iconName)

{

    CNT_ENTRY_ARGS( iconName )

    QSet<int> contactsToNotify;

    if (mIconCache.contains(iconName)) {

        CntIconCacheItem* item = mIconCache.take(iconName);

        contactsToNotify = item->contactIds;

        item->contactIds.clear();

        delete item;

    }

    foreach (int contactId, contactsToNotify) {

        emitContactInfoUpdated(contactId);

    }

    CNT_EXIT

}

 */

{

    CNT_ENTRY

    }