/****************************************************************************

**

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the Qt Mobility Components.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, 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 qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include <QFileSystemWatcher>

#include <QFile>

#include <QUuid>

#include <QTimer>

#include <QDebug>

#include <qtcontacts.h>

#include "cntsymbianengine.h"

#include "qcontactchangeset.h"

#include "cntsymbiandatabase.h"

#include "cnttransformcontact.h"

#include "cntsymbiantransformerror.h"

#include "cntsymbianfilterdbms.h"

#include "cntsymbianfiltersql.h"

#include "cntsymbiansorterdbms.h"

#include "cntrelationship.h"

#include "cntdisplaylabel.h"

typedef QList<QContactLocalId> QContactLocalIdList;

typedef QPair<QContactLocalId, QContactLocalId> QOwnCardPair;

// NOTE: There is a bug with RVCT compiler which causes the local stack

// variable to corrupt if the called function leaves. As a workaround we are

// reserving the objects from heap so it will not get corrupted.

// This of course applies only to those stack variables which are passed to

// the called function or the return value of the function is placed to the

// variable

/* ... The macros changed names */

#if QT_VERSION < QT_VERSION_CHECK(4, 6, 0)

#define QT_TRAP_THROWING QT_TRANSLATE_SYMBIAN_LEAVE_TO_EXCEPTION

#define QT_TRYCATCH_LEAVING QT_TRANSLATE_EXCEPTION_TO_SYMBIAN_LEAVE

#endif

CntSymbianEngine::CntSymbianEngine(const QMap<QString, QString>& parameters, QContactManager::Error* error)

{

    *error = QContactManager::NoError;

    m_dataBase = new CntSymbianDatabase(this, error);

    //Database opened successfully

    if(*error == QContactManager::NoError) {

        m_managerUri = QContactManager::buildUri(CNT_SYMBIAN_MANAGER_NAME, parameters);

        m_transformContact = new CntTransformContact;

#ifdef SYMBIAN_BACKEND_USE_SQLITE

        m_contactFilter    = new CntSymbianFilter(*this, *m_dataBase->contactDatabase(), *m_transformContact);

#else

        m_contactFilter    = new CntSymbianFilter(*m_dataBase->contactDatabase());

        m_contactSorter    = new CntSymbianSorterDbms(*m_dataBase->contactDatabase(), *m_transformContact);

#endif

        m_relationship     = new CntRelationship(m_dataBase->contactDatabase(), m_managerUri);

        m_displayLabel     = new CntDisplayLabel();

    }

}

CntSymbianEngine::~CntSymbianEngine()

{

    delete m_contactFilter; // needs to be deleted before database

    delete m_dataBase;

    delete m_transformContact;

#ifndef SYMBIAN_BACKEND_USE_SQLITE

    delete m_contactSorter;

#endif    

    delete m_relationship;

    delete m_displayLabel;

}

/*!

 * Returns a list of the ids of contacts that match the supplied \a filter, sorted according to the given \a sortOrders.

 * Any error that occurs will be stored in \a error. Uses either the Symbian backend native filtering or in case of an

 * unsupported filter, the generic (slow) filtering of QContactManagerEngine.

 */

QList<QContactLocalId> CntSymbianEngine::contactIds(

        const QContactFilter& filter,

        const QList<QContactSortOrder>& sortOrders,

        QContactManager::Error* error) const

{

    *error = QContactManager::NoError;

    QList<QContactLocalId> result;

    if (filter.type() == QContactFilter::RelationshipFilter)

    {

        QContactRelationshipFilter rf = static_cast<QContactRelationshipFilter>(filter);

        // XXX enum changed classes - engine API will reflect this eventually

        QList<QContactRelationship> relationshipsList = relationships(

            rf.relationshipType(), rf.relatedContactId(), rf.relatedContactRole(), error);

        if(*error == QContactManager::NoError) {

            foreach(const QContactRelationship& r, relationshipsList) {

                if(rf.relatedContactRole() == QContactRelationship::First) {

                    result += r.second().localId();

                } else if (rf.relatedContactRole() == QContactRelationship::Second) {

                    result += r.first().localId();

                } else if (rf.relatedContactRole() == QContactRelationship::Either) {

                    result += r.first().localId();

                    result += r.second().localId();

                }

            }

            //slow sorting until it's supported in SQL requests

            result = slowSort(result, sortOrders, error);

        }

    }

    else

    {

        bool filterSupported(true);

        result = m_contactFilter->contacts(filter, sortOrders, filterSupported, error);

#ifdef SYMBIAN_BACKEND_USE_SQLITE

        // Remove possible false positives

        if(!filterSupported && *error == QContactManager::NotSupportedError)

            {

            result = slowFilter(filter, result, error);

            //slow sorting until it's supported in SQL requests

            result = slowSort(result, sortOrders, error);

            }

#else

        // Remove possible false positives

        if(!filterSupported && *error == QContactManager::NoError)

            result = slowFilter(filter, result, error);

        // Sort the matching contacts

        if(!sortOrders.isEmpty()&& *error == QContactManager::NoError ) {

            if(m_contactSorter->sortOrderSupported(sortOrders)) {

                result = m_contactSorter->sort(result, sortOrders, error);

            } else {

                result = slowSort(result, sortOrders, error);

            }

        }

#endif

    }

    return result;

}

QList<QContact> CntSymbianEngine::contacts(const QContactFilter& filter, const QList<QContactSortOrder>& sortOrders, const QContactFetchHint& fh, QContactManager::Error* error) const

{

    *error = QContactManager::NoError;

    QList<QContact> contacts;

    QList<QContactLocalId> contactIds = this->contactIds(filter, sortOrders, error);

    if (*error == QContactManager::NoError ) {

        foreach (QContactLocalId id, contactIds) {

            QContact contact = this->contact(id, fh, error);

            if (*error != QContactManager::NoError) {

                return QList<QContact>(); // return empty list if error occurred

            }

            contacts.append(contact);

        }

    }

    return contacts;

}

/*!

 * Read a contact from the contact database.

 *

 * \param contactId The Id of the contact to be retrieved.

 * \param error Qt error code.

 * \return A QContact for the requested QContactLocalId value or 0 if the read

 *  operation was unsuccessful (e.g. contact not found).

 */

QContact CntSymbianEngine::contact(const QContactLocalId& contactId, const QContactFetchHint& fetchHint, QContactManager::Error* error) const

{

    QContact* contact = new QContact();

    TRAPD(err, *contact = fetchContactL(contactId, fetchHint.detailDefinitionsHint()));

    CntSymbianTransformError::transformError(err, error);

    if(*error == QContactManager::NoError) {

        updateDisplayLabel(*contact);

        //check relationship only if there are no definition restrictions, otherwise

        //skip this time expensive operation.       

        if( (!fetchHint.optimizationHints() & QContactFetchHint::NoRelationships)) {

            QContactManager::Error relationshipError;

            // XXX can also consult fetchHint.relationships list

            QList<QContactRelationship> relationships = this->relationships(QString(), contact->id(), QContactRelationship::Either, &relationshipError);

            if (relationshipError != QContactManager::NoError &&

                relationshipError != QContactManager::DoesNotExistError) { // means that no relationships found

                *error = relationshipError;

            }

            QContactManagerEngine::setContactRelationships(contact, relationships);

        }

    }

    return *QScopedPointer<QContact>(contact);

}

bool CntSymbianEngine::saveContact(QContact* contact, QContactManager::Error* error)

{

    QContactChangeSet changeSet;

    TBool ret = doSaveContact(contact, changeSet, error);

    changeSet.emitSignals(this);

    return ret;

}

/*! \reimp */

bool CntSymbianEngine::saveContacts(QList<QContact> *contacts, QMap<int, QContactManager::Error> *errorMap, QContactManager::Error* error)

{

    *error = QContactManager::NoError;

    if (errorMap) {

        // if the errormap argument is null, we just don't do fine-grained reporting.            

        errorMap->clear();

    }    

    if (!contacts) {

        *error = QContactManager::BadArgumentError;

        return false;

    }

    QContactChangeSet changeSet;

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

        QContact current = contacts->at(i);

        QContactManager::Error functionError = QContactManager::NoError;

        if (!doSaveContact(&current, changeSet, &functionError)) {

            *error = functionError;

            if (errorMap) {

                errorMap->insert(i, functionError);

            }

        } else {

            (*contacts)[i] = current;

        }

    }

    changeSet.emitSignals(this);

    return (*error == QContactManager::NoError);

}

/*!

 * Uses the generic filtering implementation of QContactManagerEngine to filter

 * contacts one-by-one. Really slow when filtering a lot of contacts because

 * every contact needs to be loaded from the database before filtering.

 */

QList<QContactLocalId> CntSymbianEngine::slowFilter(

        const QContactFilter& filter,

        const QList<QContactLocalId>& contacts,

        QContactManager::Error* error

        ) const

{

    QList<QContactLocalId> result;

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

        QContactLocalId id = contacts.at(i);

        // Check if this is a false positive. If not, add to the result set.

        if(QContactManagerEngine::testFilter(filter, contact(id, QContactFetchHint(), error)))

            result << id;

    }

    return result;

}

QList<QContactLocalId> CntSymbianEngine::slowSort(

        const QList<QContactLocalId>& contactIds,

        const QList<QContactSortOrder>& sortOrders,

        QContactManager::Error* error) const

{

    // Get unsorted contacts

    QList<QContact> unsortedContacts;

    foreach (QContactLocalId id, contactIds) {

        QContact c = contact(id, QContactFetchHint(), error);

        if (*error != QContactManager::NoError)

            return QList<QContactLocalId>();

        unsortedContacts << c;

    }

    return QContactManagerEngine::sortContacts(unsortedContacts, sortOrders);

}

bool CntSymbianEngine::doSaveContact(QContact* contact, QContactChangeSet& changeSet, QContactManager::Error* error)

{

    bool ret = false;

    if(contact && !validateContact(*contact, error))

        return false;

    // If contact has GUid and no local Id, try to find it in database

    if (contact && !contact->localId() &&

        contact->details(QContactGuid::DefinitionName).count() > 0) {

        QContactDetailFilter guidFilter;

        guidFilter.setDetailDefinitionName(QContactGuid::DefinitionName, QContactGuid::FieldGuid);

        QContactGuid guidDetail = static_cast<QContactGuid>(contact->details(QContactGuid::DefinitionName).at(0));

        guidFilter.setValue(guidDetail.guid());

        QContactManager::Error err;

        QList<QContactLocalId> localIdList = contactIds(guidFilter,

                QList<QContactSortOrder>(), &err);

        if (err == QContactManager::NoError && localIdList.count() > 0) {

            QScopedPointer<QContactId> contactId(new QContactId());

            contactId->setLocalId(localIdList.at(0));

            contactId->setManagerUri(m_managerUri);

            contact->setId(*contactId);

        }

    }

    // Check parameters

    if(!contact) {

        *error = QContactManager::BadArgumentError;

        ret = false;

    // Update an existing contact

    } else if(contact->localId()) {

        if(contact->id().managerUri() == m_managerUri) {

            ret = updateContact(*contact, changeSet, error);

        } else {

            *error = QContactManager::BadArgumentError;

            ret = false;

        }

    // Create new contact

    } else {

        ret = addContact(*contact, changeSet, error);

    }

    if (ret)

        updateDisplayLabel(*contact);

    return ret;

}

/*!

 * Private leaving implementation for contact()

 */

QContact CntSymbianEngine::fetchContactL(const QContactLocalId &localId, const QStringList& definitionRestrictions) const

{

    // A contact with a zero id is not expected to exist.

    // Symbian contact database uses id 0 internally as the id of the

    // system template.

    if(localId == 0)

        User::Leave(KErrNotFound);

    // Read the contact from the CContactDatabase

    CContactItem* contactItem = m_dataBase->contactDatabase()->ReadContactL(localId);

    CleanupStack::PushL(contactItem);

    // Convert to a QContact

    QContact contact = m_transformContact->transformContactL(*contactItem, definitionRestrictions);

    // Transform details that are not available until the contact has been saved

    m_transformContact->transformPostSaveDetailsL(*contactItem, contact, *m_dataBase->contactDatabase(), m_managerUri);

    CleanupStack::PopAndDestroy(contactItem);

    return contact;

}

/*!

 * Add the specified contact item to the persistent contacts store.

 *

 * \param contact The QContact to be saved.

 * \param id The Id of new contact

 * \param qtError Qt error code.

 * \return Error status

 */

bool CntSymbianEngine::addContact(QContact& contact, QContactChangeSet& changeSet, QContactManager::Error* qtError)

{

    // Attempt to persist contact, trapping errors

    int err(0);

    QContactLocalId id(0);

    TRAP(err, id = addContactL(contact));

    if(err == KErrNone)

    {

        changeSet.insertAddedContact(id);

        m_dataBase->appendContactEmitted(id);

    }

    CntSymbianTransformError::transformError(err, qtError);

    return (err==KErrNone);

}

/*!

 * Private leaving implementation for addContact()

 *

 * \param contact The contact item to save in the database.

 * \return The new contact ID.

 */

int CntSymbianEngine::addContactL(QContact &contact)

{

    int id(0);

    //handle normal contact

    if(contact.type() == QContactType::TypeContact)

    {

        // Create a new contact card.

        CContactItem* contactItem = CContactCard::NewLC();

        m_transformContact->transformContactL(contact, *contactItem);

        // Add to the database

        id = m_dataBase->contactDatabase()->AddNewContactL(*contactItem);

        // Reload contact item

        CleanupStack::PopAndDestroy(contactItem);

        contactItem = 0;

        contactItem = m_dataBase->contactDatabase()->ReadContactLC(id);

        // Transform details that are not available until the contact has been saved

        m_transformContact->transformPostSaveDetailsL(*contactItem, contact, *m_dataBase->contactDatabase(), m_managerUri);

        CleanupStack::PopAndDestroy(contactItem);

    }

    //group contact

    else if(contact.type() == QContactType::TypeGroup)

    {

        // Create a new group, which is added to the database

        CContactItem* contactItem = m_dataBase->contactDatabase()->CreateContactGroupLC();

        //set the id for the contact, needed by update

        id = contactItem->Id();

        QScopedPointer<QContactId> contactId(new QContactId());

        contactId->setLocalId(QContactLocalId(id));

        contactId->setManagerUri(m_managerUri);

        contact.setId(*contactId);

        CleanupStack::PopAndDestroy(contactItem);

        contactItem = 0;

        //update contact, will add the fields to the already saved group

        updateContactL(contact);

        // Transform details that are not available until the contact has been saved

        contactItem = m_dataBase->contactDatabase()->ReadContactLC(id);

        m_transformContact->transformPostSaveDetailsL(*contactItem, contact, *m_dataBase->contactDatabase(), m_managerUri);

        CleanupStack::PopAndDestroy(contactItem);

    }

    // Leave with an error

    else

    {

        User::Leave(KErrInvalidContactDetail);

    }

    // Return the new ID.

    return id;

}

/*!

 * Update an existing contact entry in the database.

 *

 * \param contact The contact to update in the database.

 * \param qtError Qt error code.

 * \return Error status.

 */

bool CntSymbianEngine::updateContact(QContact& contact, QContactChangeSet& changeSet, QContactManager::Error* qtError)

{

    int err(0);

    TRAP(err, updateContactL(contact));

    if(err == KErrNone)

    {

        //TODO: check what to do with groupsChanged

        changeSet.insertChangedContact(contact.localId());

        m_dataBase->appendContactEmitted(contact.localId());

    }

    CntSymbianTransformError::transformError(err, qtError);

    return (err==KErrNone);

}

/*!

 * Private leaving implementation for updateContact()

 *

 * \param contact The contact to update in the database.

 */

void CntSymbianEngine::updateContactL(QContact &contact)

{

    // Need to open the contact for write, leaving this item

    // on the cleanup stack to unlock the item in the event of a leave.

    CContactItem* contactItem = m_dataBase->contactDatabase()->OpenContactLX(contact.localId());

    CleanupStack::PushL(contactItem);

    // Cannot update contact type. The client needs to do this itself.

    if ((contact.type() == QContactType::TypeContact && contactItem->Type() != KUidContactCard &&

            contactItem->Type() != KUidContactOwnCard) ||

        (contact.type() == QContactType::TypeGroup && contactItem->Type() != KUidContactGroup)){

        User::Leave(KErrAlreadyExists);

    }

    // Copy the data from QContact to CContactItem

    m_transformContact->transformContactL(contact, *contactItem);

    // Write the entry using the converted  contact

    // note commitContactL removes empty fields from the contact

    m_dataBase->contactDatabase()->CommitContactL(*contactItem);

    // Update "last modified" time stamp; the contact item needs to be

    // explicitly refreshed by reading it again from the database

    CleanupStack::PopAndDestroy(contactItem);

    contactItem = 0;

    contactItem = m_dataBase->contactDatabase()->ReadContactLC(contact.localId());

    m_transformContact->transformPostSaveDetailsL(*contactItem, contact, *m_dataBase->contactDatabase(), m_managerUri);