/*

* 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: Asynchronously fetches and caches basic contact info

*              and icons.

*

*/

#include <hbapplication.h>

#include <qtcontacts.h>

#include <qcontactmanager.h>

#include <QTimer>

#include <cntcache.h>

#include <cntcacheitems.h>

#include <cntnamefetcher.h>

#include <cntinfofetcher.h>

#include <cnticonfetcher.h>

#include <cntdebug.h>

/*!

    \class CntContactInfo

    \brief Info about one contact, intended for list views.

   This class contains info about one contact. The info is mainly intended

   to be used in list views:

     - name: the name of the contact, formatted for displaying

     - text: secondary information like a phone number

     - icon1: the main icon

     - icon2: the smaller secondary icon

    \class CntCache

    \brief Asynchronously fetches contact info and icons.

    Singleton class that acts as a proxy to get CntContactInfo objects for

    contacts. It also implements caching for faster access. This is why the

    fetchContactInfo() function takes a row number and the full list of

    contact IDs rather than just a contact ID -- it allows precaching.

    The usage pattern for clients is to call fetchContactInfo() to get at

    least the name of the contact. If all the info is cached then it will be

    provided. If not, then the uncached info is fetched asynchronously and

    contactInfoUpdated() signals are emitted as the pieces of information

    arrive -- up to three times per contact; once for text, once for icon1

    and once for icon2.

    Internally CntCache uses three fetchers; one for names, one for info and

    one for icons.

 */

// set the singleton instance pointer to NULL

CntCache* CntCache::mInstance = NULL;

// the event for starting to process all outstanding jobs

const QEvent::Type ProcessJobsEvent = QEvent::User;

// different states of postponement 

const int JobsNotPostponed = 0;

const int JobsPostponedForDuration = 1;

const int JobsPostponedUntilResume = 2;

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

const int ItemsToCacheAhead = 24;

// cache size for info items

const int InfoCacheSize = 128;

// cache size for icon items; must be larger than 2 * ItemsToCacheAhead

const int IconCacheSize = 60;

// duration of urgency mode in milliseconds

const int UrgencyModeDuration = 100;

// duration of a postponement in milliseconds

const int PostponeJobsDuration = 300;

// number of icons in a CntContactInfo object

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

const QString EmptyTextField = " ";

/*!

    Provides a pointer to the CntCache singleton instance.

    \param client a pointer to the client

    \param manager  

 */

CntCache* CntCache::createSession(void *client, QContactManager *manager)

{

	CNT_STATIC_ENTRY_ARGS("client =" << client << ", mngr =" << (void*) manager)

    if (!mInstance) {

        mInstance = new CntCache(manager);

    }

    // increase reference counter for cache clients

    mInstance->mClients.insert(client);

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

    // for the first screenful of contacts urgently

    mInstance->startUrgencyMode();

	CNT_EXIT_ARGS("instance =" << (void*) mInstance << ", refCount =" << mInstance->mClients.count())

    return mInstance;

}

/*!

    Disconnects from CntCache.

 */

void CntCache::closeSession(void *client)

{

	CNT_ENTRY

    // delete singleton instance if there are no more clients

    mInstance->mClients.remove(client);

    if (mInstance->mClients.count() == 0) {

    	CNT_LOG_ARGS("no more clients, so deleting singleton instance")

        mInstance = NULL;

        delete this;

    }

	CNT_EXIT

}

/*! 

    Fetches visuals for 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 precached.

    \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];

    QContactLocalId contactId = idList.at(row);

    if (contactId != mLastEmittedContactId) {

        // this is a new request from the UI (rather than a response to

        // a change that the cache just emitted)

        if (!mIsInUrgencyMode) {

            postponeJobs(JobsPostponedForDuration, PostponeJobsDuration);

        }

        updateReadAheadCache(row, idList);

    }

    // fetch the contact

    if (mInfoCache.contains(contactId)) {

        // the contact's info is cached

        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);

                    if (iconItem->requestedBy.count() > 0) {

                    // icon is being fetched -> add this contact to list of requestors

                        iconItem->requestedBy << contactId;

                    }

                    iconItem->lastRequest = QTime::currentTime();

                    icons[i] = iconItem->icon;

                } else {

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

                    CntIconCacheItem* iconItem = createIconCacheItem(iconName);

                    iconItem->requestedBy << contactId;

                    mIconFetcher->scheduleJob(new CntIconJob(iconName), row);

                }

            }

        }

        // set return text

        text = infoItem->text;

        // update cache order

        infoItem->lastRequest = QTime::currentTime();

    } else if (contactExists(contactId)) {

        // contact exists but info is not in cache, so schedule it for retrieval

        CntInfoCacheItem* item = createInfoCacheItem(contactId);

        item->text = text;

        mInfoFetcher->scheduleJob(new CntInfoJob(contactId), row);

    } else {

        return NULL;

    }

    name = contactName(contactId);

    if (!mProcessingJobs && mJobsPostponed == JobsNotPostponed) {

        // there might be new jobs now

        mProcessingJobs = true;

        HbApplication::instance()->postEvent(this, new QEvent(ProcessJobsEvent));

    }

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

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

}

/*! 

    Creates a list of contact ids sorted according the corresponding contact names.

    \param idFilter the IDs to be returned; if NULL, all contact IDs are returned

    \return the list of ids, sorted by contact name

 */

QList<QContactLocalId> CntCache::sortIdsByName(const QSet<QContactLocalId>* idFilter) const

{

    CNT_ENTRY

    QList<QContactLocalId> sortedIds;

    // allocate memory in advance to avoid repeated reallocation during population

    // an extra 16 items are allocated to leave room for a few more contacts

    // before reallocation is needed

    if (!idFilter) {

        sortedIds.reserve(mSortedNames.count() + 16);

    } else {

        sortedIds.reserve(idFilter->count() + 16);

    }

    // the entries in mSortedNames are already sorted, so just pick

    // out the ids from that list in the order that they appear

    if (!idFilter) {

        foreach (CntNameCacheItem* item, mSortedNames) {

            sortedIds.append(item->contactId());

        }

    } else {

        foreach (CntNameCacheItem* item, mSortedNames) {

            if (idFilter->contains(item->contactId())) {

                sortedIds.append(item->contactId());

            }

        }

    }

    CNT_EXIT

    return sortedIds;

}

/*!

    Overloaded version of the function for string based searching of contact

    names. Currently for multi part names only space and dash variations are

    used for filtering, e.g. "A B" matches "Beta, Alfa" and "Alfa, Beta",

    but also "Gamma, Alfa-Beta" and "Gamma, Alfa Beta" and "Alfa Beta, Gamma".

    \param searchList list of strings to search for

    \return the list of ids, sorted by contact name

 */

QList<QContactLocalId> CntCache::sortIdsByName(const QStringList &searchList) const

{

    CNT_ENTRY_ARGS("time:" << User::FastCounter());

    QList<QContactLocalId> sortedIds;

    QSet<int> checkedNames;

    QStringList searchListSorted;

    // the given search string must be ordered to descending order according to word length

    // so the search algorithm finds the correct contacts, this prevents cases where search string

    // is e.g. "ax axx" so names starting with "axxyyz axyz" don't cause any problems for the search

    foreach (QString oneString, searchList) {

        searchListSorted.append(oneString.toLower());

    }

    qSort(searchListSorted.begin(), searchListSorted.end(), qGreater<QString>());

    for (int iter = 0; iter < mSortedNames.size(); iter++) {

        int searchIndex;

        QString currentName = (mSortedNames.at(iter))->name();

        checkedNames.clear();

        for (searchIndex = 0; searchIndex < searchListSorted.size(); searchIndex++) {

            int currentPos;

            int tempStartPos = 0;

            for (currentPos = 0; currentPos <= currentName.length(); currentPos++) {

                // at the moment only differentiating character is the space (" ")

                if (currentPos == currentName.length() || currentName.at(currentPos) == ' ') {

                    QString tempName = currentName.mid(tempStartPos, currentPos - tempStartPos);

                    if (!checkedNames.contains(tempStartPos)

                        && tempName.startsWith(searchListSorted.at(searchIndex), Qt::CaseInsensitive)) {

                        checkedNames.insert(tempStartPos);

                        break;

                    }

                    tempStartPos = ++currentPos;

                }

            }

            // if the name is parsed completely through then it can't be a match

            if (currentPos > currentName.length()) {

                break;

            }

        }

        // if the whole search parameter list is parsed, then the name must match the given search string

        if (searchIndex == searchListSorted.size()) {

            sortedIds.append(mSortedNames.at(iter)->contactId());

        }

    }

    CNT_EXIT_ARGS("time:" << User::FastCounter());

    return sortedIds;

}

/*!

    Creates the CntCache singleton instance.

 */

CntCache::CntCache(QContactManager *manager)

    : mContactManager(manager),

      mNameFetcher(new CntNameFetcher()),

      mInfoFetcher(new CntInfoFetcher(mContactManager)),

      mIconFetcher(new CntIconFetcher()),

      mProcessingJobs(false),

      mJobsPostponed(JobsNotPostponed),

      mIsInUrgencyMode(false),

      mLastEmittedContactId(-1),

      mHasModifiedNames(false),

      mAllNamesFetchStarted(false)

{

    CNT_ENTRY

    // listen to name fetcher

    QObject::connect(mNameFetcher, SIGNAL(nameFormatChanged(CntNameOrder)),

            this, SLOT(reformatNames(CntNameOrder)));

    QObject::connect(mNameFetcher, SIGNAL(databaseAccessComplete()),

            this, SLOT(resumeJobs()));

    QObject::connect(mNameFetcher, SIGNAL(namesAvailable(QList<CntNameCacheItem *>)),

            this, SLOT(setNameList(QList<CntNameCacheItem *>)));

    // listen to info fetcher

    QObject::connect(mInfoFetcher, SIGNAL(infoUpdated(QContactLocalId, const ContactInfoField &, const QString &)),

            this, SLOT(updateCachedInfo(QContactLocalId, const ContactInfoField &, const QString &)));

    QObject::connect(mInfoFetcher, SIGNAL(infoCancelled(QContactLocalId)),

            this, SLOT(cancelInfoFetch(QContactLocalId)));

    // listen to icon fetcher

    QObject::connect(mIconFetcher, SIGNAL(iconFetched(const QString &, const HbIcon &)),

            this, SLOT(updateCachedIcon(const QString &, const HbIcon &)));

    QObject::connect(mIconFetcher, SIGNAL(iconCancelled(const QString &)),

            this, SLOT(cancelIconFetch(const QString &)));

    // listen to contact manager

    QObject::connect(mContactManager, SIGNAL(contactsChanged(const QList<QContactLocalId>&)),

            this, SLOT(updateContacts(const QList<QContactLocalId>&)));

    QObject::connect(mContactManager, SIGNAL(contactsRemoved(const QList<QContactLocalId>&)),

            this, SLOT(removeContacts(const QList<QContactLocalId>&)));

    QObject::connect(mContactManager, SIGNAL(contactsAdded(const QList<QContactLocalId>&)),

            this, SLOT(addContacts(const QList<QContactLocalId>&)));

    // listen to timer events; this is for postponing and resuming jobs

    mResumeJobsTimer.setSingleShot(true);

    QObject::connect(&mResumeJobsTimer, SIGNAL(timeout()), this, SLOT(resumeJobs()));

    // load all names to cache

    loadNames();

    CNT_EXIT

}

/*!

    Destructs the CntCache singleton instance.

 */

CntCache::~CntCache()

{

    CNT_ENTRY

    QObject::disconnect(this);

    if (mHasModifiedNames) {

        mNameFetcher->writeNamesToCache(mSortedNames);

    }

    delete mNameFetcher;

    delete mInfoFetcher;

    delete mIconFetcher;

    qDeleteAll(mInfoCache);

    mInfoCache.clear();

    qDeleteAll(mIconCache);

    mIconCache.clear();

    qDeleteAll(mNameCache);

    mNameCache.clear();

    mSortedNames.clear();   // contains same data as mNameCache, so no qDeleteAll

    CNT_EXIT

}

/*!

    Postpones outstanding jobs until milliseconds ms has passed or resumeJobs() is called.

    \param postponement Type the type of postponement; UntilResume or ForDuration

    \param milliseconds The duration of the delay

 */

void CntCache::postponeJobs(int postponementType, int duration)

{

    CNT_ENTRY_ARGS("ms =" << duration)

    Q_ASSERT((postponementType == JobsPostponedUntilResume

             || postponementType == JobsPostponedForDuration)

             && duration >= 0);

    mJobsPostponed = postponementType;

    mResumeJobsTimer.stop();

    if (postponementType == JobsPostponedForDuration) {

        mResumeJobsTimer.start(duration);

    }

    CNT_EXIT_ARGS("type =" << mJobsPostponed)

}

/*!

    Postpones outstanding jobs until resumeJobs() is called. This must always be called after

    postponeJobs.

 */

void CntCache::resumeJobs()

{

    CNT_ENTRY

    Q_ASSERT(!mProcessingJobs && mJobsPostponed != JobsNotPostponed);

    mResumeJobsTimer.stop();

    mJobsPostponed = JobsNotPostponed;

    mProcessingJobs = true;

    HbApplication::instance()->postEvent(this, new QEvent(ProcessJobsEvent));

    CNT_EXIT

}

/*!

    Listens for ProcessJobsEvents and calls processJobs() if there is such an event.

 */

bool CntCache::event(QEvent* event)

{

    if (event->type() == ProcessJobsEvent) {

        processJobs();

        return true;

    }

    return QObject::event(event);

}

/*!

    Processes all scheduled jobs in all fetchers. The loop runs until all

    jobs are done or postponed.

 */

void CntCache::processJobs()

{

    CNT_ENTRY

    // process fetcher jobs in order of priority

    forever {

        // 1: has all jobs been postponed?

        if (mJobsPostponed != JobsNotPostponed) {

            CNT_EXIT_ARGS("jobs postponed")

            mProcessingJobs = false;

            return;

        // 2: is there a request to fetch info?

        } else if (mInfoFetcher->hasScheduledJobs()) {

            mInfoFetcher->processNextJob();

        // 3: is there a request to fetch an icon?

        } else if (mIconFetcher->hasScheduledJobs()) {

            // quit the loop; it will be started again when the icon has been fetched

            if (!mIconFetcher->isProcessingJob()) {

                mIconFetcher->processNextJob();

            }

            mProcessingJobs = false;

            CNT_EXIT_ARGS("jobs postponed until icon fetch returns")

            return;

        // 4: are there any cancelled info jobs?

        } else if (mInfoFetcher->hasCancelledJobs() && !mInfoFetcher->isProcessingJob()) {

            mInfoFetcher->processNextJob();

        // 5: are there any cancelled icon jobs?

        } else if (mIconFetcher->hasCancelledJobs() && !mIconFetcher->isProcessingJob()) {

            mIconFetcher->processNextJob();

        // 6: is there an "all names" job?

        } else if (mNameFetcher->hasScheduledJobs()) {

            // fetch all contact names from the database so that the current

            // list of names (from the file cache) can be synched with the

            // database

            if (!mNameFetcher->isProcessingJob()) {

                mNameFetcher->processNextJob();

            }

            mProcessingJobs = false;

            postponeJobs(JobsPostponedUntilResume);

            CNT_EXIT_ARGS("jobs postponed while fetching all names")

            return;

        // 7: are there contacts left to precache?

        } else if (mReadAheadCache.count() > 0) {

            int contactId = mReadAheadCache.first().first;

            int contactRow = mReadAheadCache.takeFirst().second;

            if (!mInfoCache.contains(contactId) && contactExists(contactId)) {

                // contact exists, but is not in cache, so schedule it for retrieval

                CntInfoCacheItem* item = createInfoCacheItem(contactId);

                item->text = EmptyTextField;

                mInfoFetcher->scheduleJob(new CntInfoJob(contactId), contactRow);

            }

        // nothing more to do, so exit loop

        } else {