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

**

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

** 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 "qcontactmanager.h"

#include "qcontact_p.h"

#include "qcontactfilter.h"

#include "qcontactdetaildefinition.h"

#include "qcontactmanager_p.h"

#include <QSharedData>

#include <QPair>

#include <QSet>

QTM_BEGIN_NAMESPACE

/*!

  \class QContactManager

  \brief The QContactManager class provides clients with access to contact information stored in a particular backend.

  \ingroup contacts-main

  This class provides adding, updating and removal of contacts.

  It also provides definitions for details and fields that can be found in contacts.

 */

/*!

  \fn QContactManager::dataChanged()

  This signal is emitted by the manager if its internal state changes, and it is unable to determine the changes

  which occurred, or if the manager considers the changes to be radical enough to require clients to reload all data.

  If this signal is emitted, no other signals will be emitted for the associated changes.

 */

/*!

  \fn QContactManager::contactsAdded(const QList<QContactLocalId>& contactIds)

  This signal is emitted at some point once the contacts identified by \a contactIds have been added to a datastore managed by this manager.

  This signal must not be emitted if the dataChanged() signal was previously emitted for these changes.

 */

/*!

  \fn QContactManager::contactsChanged(const QList<QContactLocalId>& contactIds)

  This signal is emitted at some point once the contacts identified by \a contactIds have been modified in a datastore managed by this manager.

  This signal must not be emitted if the dataChanged() signal was previously emitted for these changes.

 */

/*!

  \fn QContactManager::contactsRemoved(const QList<QContactLocalId>& contactIds)

  This signal is emitted at some point once the contacts identified by \a contactIds have been removed from a datastore managed by this manager.

  This signal must not be emitted if the dataChanged() signal was previously emitted for these changes.

 */

/*!

  \fn QContactManager::relationshipsAdded(const QList<QContactLocalId>& affectedContactIds)

  This signal is emitted at some point after relationships have been added to the manager which involve the contacts identified by \a affectedContactIds.

  This signal must not be emitted if the dataChanged() signal was previously emitted for these changes.

 */

/*!

  \fn QContactManager::relationshipsRemoved(const QList<QContactLocalId>& affectedContactIds)

  This signal is emitted at some point after relationships have eben removed from the manager which involve the contacts identified by \a affectedContactIds.

  This signal must not be emitted if the dataChanged() signal was previously emitted for these changes.

 */

/*!

  \fn QContactManager::selfContactIdChanged(const QContactLocalId& oldId, const QContactLocalId& newId)

  This signal is emitted at some point after the id of the self-contact is changed from \a oldId to \a newId in the manager.

  If the \a newId is the invalid, zero id, then the self contact was deleted or no self contact exists.

  This signal must not be emitted if the dataChanged() signal was previously emitted for this change.

 */

#define makestr(x) (#x)

#define makename(x) makestr(x)

/*!

    Returns a list of available manager ids that can be used when constructing

    a QContactManager.  If an empty id is specified to the constructor, the

    first value in this list will be used instead.

  */

QStringList QContactManager::availableManagers()

{

    QStringList ret;

    ret << QLatin1String("memory") << QLatin1String("invalid");

    QContactManagerData::loadFactories();

    ret.append(QContactManagerData::m_engines.keys());

    // now swizzle the default engine to pole position

#if defined(Q_CONTACTS_DEFAULT_ENGINE)

    if (ret.removeAll(QLatin1String(makename(Q_CONTACTS_DEFAULT_ENGINE)))) {

        ret.prepend(QLatin1String(makename(Q_CONTACTS_DEFAULT_ENGINE)));

    }

#endif

    return ret;

}

/*!

  Splits the given \a uri into the manager, store, and parameters that it describes, and places the information into the memory addressed by \a pManagerId and \a pParams respectively.  Returns true if \a uri could be split successfully, otherwise returns false

 */

bool QContactManager::parseUri(const QString& uri, QString* pManagerId, QMap<QString, QString>* pParams)

{

    // Format: qtcontacts:<managerid>:<key>=<value>&<key>=<value>

    // 1) parameters are currently a qstringlist.. should they be a map?

    // 2) is the uri going to be escaped?  my guess would be "probably not"

    // 3) hence, do we assume that the prefix, managerid and storeid cannot contain `:'

    // 4) similarly, that neither keys nor values can contain `=' or `&'

    QStringList colonSplit = uri.split(QLatin1Char(':'));

    QString prefix = colonSplit.value(0);

    if (prefix != QLatin1String("qtcontacts"))

        return false;

    QString managerName = colonSplit.value(1);

    if (managerName.trimmed().isEmpty())

        return false;

    QString firstParts = prefix + QLatin1Char(':') + managerName + QLatin1Char(':');

    QString paramString = uri.mid(firstParts.length());

    QMap<QString, QString> outParams;

    // Now we have to decode each parameter

    if (!paramString.isEmpty()) {

        QStringList params = paramString.split(QRegExp(QLatin1String("&(?!(amp;|equ;))")), QString::KeepEmptyParts);

        // If we have an empty string for paramstring, we get one entry in params,

        // so skip that case.

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

            /* This should be something like "foo&bar&equ;=grob&" */

            QStringList paramChunk = params.value(i).split(QLatin1String("="), QString::KeepEmptyParts);

            if (paramChunk.count() != 2)

                return false;

            QString arg = paramChunk.value(0);

            QString param = paramChunk.value(1);

            arg.replace(QLatin1String("&equ;"), QLatin1String("="));

            arg.replace(QLatin1String("&"), QLatin1String("&"));

            param.replace(QLatin1String("&equ;"), QLatin1String("="));

            param.replace(QLatin1String("&"), QLatin1String("&"));

            if (arg.isEmpty())

                return false;

            outParams.insert(arg, param);

        }

    }

    if (pParams)

        *pParams = outParams;

    if (pManagerId)

        *pManagerId = managerName;

    return true;

}

/*! Returns a URI that completely describes a manager implementation, datastore, and the parameters with which to instantiate the manager, from the given \a managerName, \a params and an optional \a implementationVersion */

QString QContactManager::buildUri(const QString& managerName, const QMap<QString, QString>& params, int implementationVersion) 

{

    QString ret(QLatin1String("qtcontacts:%1:%2"));

    // we have to escape each param

    QStringList escapedParams;

    QStringList keys = params.keys();

    for (int i=0; i < keys.size(); i++) {

        QString key = keys.at(i);

        QString arg = params.value(key);

        arg = arg.replace(QLatin1Char('&'), QLatin1String("&"));

        arg = arg.replace(QLatin1Char('='), QLatin1String("&equ;"));

        key = key.replace(QLatin1Char('&'), QLatin1String("&"));

        key = key.replace(QLatin1Char('='), QLatin1String("&equ;"));

        key = key + QLatin1Char('=') + arg;

        escapedParams.append(key);

    }

    if (implementationVersion != -1) {

        QString versionString = QString(QLatin1String(QTCONTACTS_IMPLEMENTATION_VERSION_NAME));

        versionString += QString::fromAscii("=");

        versionString += QString::number(implementationVersion);

        escapedParams.append(versionString);

    }

    return ret.arg(managerName, escapedParams.join(QLatin1String("&")));

}

/*!

  Constructs a QContactManager whose implementation, store and parameters are specified in the given \a storeUri,

  and whose parent object is \a parent.

 */

QContactManager* QContactManager::fromUri(const QString& storeUri, QObject* parent)

{

    if (storeUri.isEmpty()) {

        return new QContactManager(QString(), QMap<QString, QString>(), parent);

    } else {

        QString id;

        QMap<QString, QString> parameters;

        if (parseUri(storeUri, &id, &parameters)) {

            return new QContactManager(id, parameters, parent);

        } else {

            // invalid

            return new QContactManager(QLatin1String("invalid"), QMap<QString, QString>(), parent);

        }

    }

}

/*!

  Constructs a QContactManager whose parent QObject is \a parent.

  The default implementation for the platform will be created.

 */

QContactManager::QContactManager(QObject* parent)

    : QObject(parent)

{

    createEngine(QString(), QMap<QString, QString>());

}

/*!

  Constructs a QContactManager whose implementation is identified by \a managerName with the given \a parameters.

  The \a parent QObject will be used as the parent of this QContactManager.

  If an empty \a managerName is specified, the default implementation for the platform will

  be used.

 */

QContactManager::QContactManager(const QString& managerName, const QMap<QString, QString>& parameters, QObject* parent)

    : QObject(parent),

    d(new QContactManagerData)

{

    createEngine(managerName, parameters); 

} 

void QContactManager::createEngine(const QString& managerName, const QMap<QString, QString>& parameters) 

{ 

    d->createEngine(managerName, parameters);

    connect(d->m_engine, SIGNAL(dataChanged()), this, SIGNAL(dataChanged()));

    connect(d->m_engine, SIGNAL(contactsAdded(QList<QContactLocalId>)), this, SIGNAL(contactsAdded(QList<QContactLocalId>)));

    connect(d->m_engine, SIGNAL(contactsChanged(QList<QContactLocalId>)), this, SIGNAL(contactsChanged(QList<QContactLocalId>)));

    connect(d->m_engine, SIGNAL(contactsRemoved(QList<QContactLocalId>)), this, SIGNAL(contactsRemoved(QList<QContactLocalId>)));

    connect(d->m_engine, SIGNAL(relationshipsAdded(QList<QContactLocalId>)), this, SIGNAL(relationshipsAdded(QList<QContactLocalId>)));

    connect(d->m_engine, SIGNAL(relationshipsRemoved(QList<QContactLocalId>)), this, SIGNAL(relationshipsRemoved(QList<QContactLocalId>)));

    connect(d->m_engine, SIGNAL(selfContactIdChanged(QContactLocalId,QContactLocalId)), this, SIGNAL(selfContactIdChanged(QContactLocalId,QContactLocalId)));

}

/*!

  Constructs a QContactManager whose backend has the name \a managerName and version \a implementationVersion, where the manager

  is constructed with the provided \a parameters.

  The \a parent QObject will be used as the parent of this QContactManager.

  If an empty \a managerName is specified, the default implementation for the platform will be instantiated.

  If the specified implementation version is not available, the manager with the name \a managerName with the default implementation version is instantiated.

 */

QContactManager::QContactManager(const QString& managerName, int implementationVersion, const QMap<QString, QString>& parameters, QObject* parent) 

    : QObject(parent), 

    d(new QContactManagerData) 

{ 

    QMap<QString, QString> params = parameters; 

    params[QString(QLatin1String(QTCONTACTS_IMPLEMENTATION_VERSION_NAME))] = QString::number(implementationVersion);

    createEngine(managerName, params); 

} 

/*! Frees the memory used by the QContactManager */

QContactManager::~QContactManager()

{

    delete d;

}

/*!

  \enum QContactManager::Error

  This enum specifies an error that occurred during the most recent operation:

  \value NoError The most recent operation was successful

  \value DoesNotExistError The most recent operation failed because the requested contact or detail definition does not exist

  \value AlreadyExistsError The most recent operation failed because the specified contact or detail definition already exists

  \value InvalidDetailError The most recent operation failed because the specified contact contains details which do not conform to their definition

  \value InvalidRelationshipError The most recent operation failed because the specified relationship is circular or references an invalid local contact

  \value InvalidContactTypeError The most recent operation failed because the contact type specified was not valid for the operation

  \value LockedError The most recent operation failed because the datastore specified is currently locked

  \value DetailAccessError The most recent operation failed because a detail was modified or removed and its access method does not allow that

  \value PermissionsError The most recent operation failed because the caller does not have permission to perform the operation

  \value OutOfMemoryError The most recent operation failed due to running out of memory

  \value VersionMismatchError The most recent operation failed because the backend of the manager is not of the required version

  \value LimitReachedError The most recent operation failed because the limit for that type of object has been reached

  \value NotSupportedError The most recent operation failed because the requested operation is not supported in the specified store

  \value BadArgumentError The most recent operation failed because one or more of the parameters to the operation were invalid

  \value UnspecifiedError The most recent operation failed for an undocumented reason

 */

/*! Return the error code of the most recent operation */

QContactManager::Error QContactManager::error() const

{

    return d->m_error;

}

/*!

  Return the list of contact ids, sorted according to the given list of \a sortOrders

 */

QList<QContactLocalId> QContactManager::contactIds(const QList<QContactSortOrder>& sortOrders) const

{

    return d->m_engine->contactIds(sortOrders, d->m_error);

}

/*!

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

  Depending on the backend, this filtering operation may involve retrieving all the contacts.

 */

QList<QContactLocalId> QContactManager::contactIds(const QContactFilter& filter, const QList<QContactSortOrder>& sortOrders) const

{

    return d->m_engine->contactIds(filter, sortOrders, d->m_error);

}

/*!

  Returns the list of contacts stored in the manager sorted according to the given list of \a sortOrders.

  The \a definitionRestrictions parameter describes the details that are of

  interest, as a performance hint.  If the list is empty, all existing details for the matching

  contacts will be returned.  Otherwise, the returned contacts may only contain details of the

  supplied definition names, although the manager is free to return extra details.

 */

QList<QContact> QContactManager::contacts(const QList<QContactSortOrder>& sortOrders, const QStringList& definitionRestrictions) const

{

    return d->m_engine->contacts(sortOrders, definitionRestrictions, d->m_error);

}

/*!

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

  Depending on the manager implementation, this filtering operation might be slow and involve retrieving all the

  contacts and testing them against the supplied filter - see the \l isFilterSupported() function.

  The \a definitionRestrictions parameter describes the details that are of

  interest, as a performance hint.  If the list is empty, all existing details for the matching

  contacts will be returned.  Otherwise, the returned contacts may only contain details of the

  supplied definition names, although the manager is free to return extra details.

 */

QList<QContact> QContactManager::contacts(const QContactFilter& filter, const QList<QContactSortOrder>& sortOrders, const QStringList& definitionRestrictions) const

{

    return d->m_engine->contacts(filter, sortOrders, definitionRestrictions, d->m_error);

}

/*!

  Returns the contact in the database identified by \a contactId.

  If the contact does not exist, an empty, default constructed QContact will be returned,

  and the error returned by \l error() will be \c QContactManager::DoesNotExistError.

  The \a definitionRestrictions parameter describes the details that are of

  interest, as a performance hint.  If the list is empty, all existing details for the requested

  contact will be returned.  Otherwise, the returned contact may only contain details of the

  supplied definition names, although the manager is free to return extra details.

 */

QContact QContactManager::contact(const QContactLocalId& contactId, const QStringList& definitionRestrictions) const

{

    return d->m_engine->contact(contactId, definitionRestrictions, d->m_error);

}

/*!

  Adds the given \a contact to the database if \a contact has a

  default-constructed id, or an id with the manager URI set to the URI of

  this manager and a local id of zero.

  If the manager URI of the id of the \a contact is neither empty nor equal to the URI of

  this manager, or local id of the \a contact is non-zero but does not exist in the

  manager, the operation will fail and calling error() will return

  \c QContactManager::DoesNotExistError.

  Alternatively, the function will update the existing contact in the database if \a contact

  has a non-zero id and currently exists in the database.

  If the \a contact contains one or more details whose definitions have

  not yet been saved with the manager, the operation will fail and calling

  error() will return \c QContactManager::UnsupportedError.

  If the \a contact has had its relationships reordered, the manager

  will check to make sure that every relationship that the contact is currently

  involved in is included in the reordered list, and that no relationships which

  either do not involve the contact, or have not been saved in the manager are

  included in the list.  If these conditions are not met, the function will

  return \c false and calling error() will return

  \c QContactManager::InvalidRelationshipError.

  Returns false on failure, or true on

  success.  On successful save of a contact with an id of zero, its

  id will be set to a new, valid id with the manager URI set to the URI of

  this manager, and the local id set to a new, valid local id.

  The manager will automatically synthesize the display label of the contact when it is saved.

  The manager is not required to fetch updated details of the contact on save,

  and as such, clients should fetch a contact if they want the most up-to-date information

  by calling \l QContactManager::contact().

  \sa managerUri()

 */

bool QContactManager::saveContact(QContact* contact)

{

    return d->m_engine->saveContact(contact, d->m_error);

}

/*!

  Remove the contact identified by \a contactId from the database,

  and also removes any relationships in which the contact was involved.

  Returns true if the contact was removed successfully, otherwise

  returns false.

 */

bool QContactManager::removeContact(const QContactLocalId& contactId)

{

    return d->m_engine->removeContact(contactId, d->m_error);

}

/*!

  \internal

  Adds the list of contacts given by \a contactList to the database.

  Returns a list of the error codes corresponding to the contacts in

  the \a contactList.  The \l QContactManager::error() function will

  only return \c QContactManager::NoError if all contacts were saved

  successfully.

  For each newly saved contact that was successful, the uid of the contact

  in the list will be updated with the new value.  If a failure occurs

  when saving a new contact, the id will be cleared.  If a failure occurs

  when updating a contact that already exists, then TODO.

  This function was deprecated in week 1 and will be removed after the transition period has elapsed.

  \sa QContactManager::saveContact()

 */

QList<QContactManager::Error> QContactManager::saveContacts(QList<QContact>* contactList)

{

    if (contactList) {

        QMap<int, QContactManager::Error> errorMap;

        QList<QContactManager::Error> errorList;

        int size = contactList->size();

        d->m_engine->saveContacts(contactList, &errorMap, d->m_error);

        for (int j=0; j < size; j++) {

            if (errorMap.contains(j))

                errorList << errorMap.value(j);

            else

                errorList << QContactManager::NoError;

        }

        return errorList;

    } else {

        d->m_error = QContactManager::BadArgumentError;

        return QList<QContactManager::Error>();

    }

}

/*!

  Adds the list of contacts given by \a contacts list to the database.

  Returns true if the contacts were saved successfully, otherwise false.

  The manager might populate \a errorMap (the map of indices of the \a contacts list to

  the error which occurred when saving the contact at that index) for

  every index for which the contact could not be saved, if it is able.

  The \l QContactManager::error() function will only return \c QContactManager::NoError

  if all contacts were saved successfully.

  For each newly saved contact that was successful, the id of the contact

  in the \a contacts list will be updated with the new value.  If a failure occurs

  when saving a new contact, the id will be cleared.

  \sa QContactManager::saveContact()

 */

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

{

    return d->m_engine->saveContacts(contacts, errorMap, d->m_error);

}

/*!

  Remove every contact whose id is contained in the list of contacts ids

  \a contactIds.  Returns true if all contacts were removed successfully,

  otherwise false.

  The manager might populate \a errorMap (the map of indices of the \a contactIds list to

  the error which occurred when saving the contact at that index) for every

  index for which the contact could not be removed, if it is able.

  The \l QContactManager::error() function will

  only return \c QContactManager::NoError if all contacts were removed

  successfully.

  For each contact that was removed succesfully, the corresponding

  id in the \a contactIds list will be retained but set to zero.  The id of contacts

  that were not successfully removed will be left alone.

  Any contact that was removed successfully will have the relationships

  in which it was involved removed also.

  \sa QContactManager::removeContact()

 */

bool QContactManager::removeContacts(QList<QContactLocalId>* contactIds, QMap<int, QContactManager::Error>* errorMap)

{

    return d->m_engine->removeContacts(contactIds, errorMap, d->m_error);

}

/*!