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

**

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

#include "qcontactmanagerengine.h"

#include "qcontactabstractrequest.h"

#include "qcontactrequests.h"

#include "qcontactchangeset.h"

#include "qcontactdetails.h"

#include "qcontactmemorybackend_p.h"

#include <QTimer>

#include <QUuid>

#include <QSharedData>

QTM_BEGIN_NAMESPACE

/*!

  \class QContactMemoryEngine

  \brief The QContactMemoryEngine class provides an in-memory implementation

  of a contacts backend.

  It may be used as a reference implementation, or when persistent storage is not required.

  During construction, it will load the in-memory data associated with the memory store

  identified by the "id" parameter from the given parameters if it exists, or a new,

  anonymous store if it does not.

  Data stored in this engine is only available in the current process.

  This engine supports sharing, so an internal reference count is increased

  whenever a manager uses this backend, and is decreased when the manager

  no longer requires this engine.

 */

/* static data for manager class */

/*!

 * Factory function for creating a new in-memory backend, based

 * on the given \a parameters.

 *

 * The same engine will be returned for multiple calls with the

 * same value for the "id" parameter, while one of them is in scope.

 */

QContactMemoryEngine* QContactMemoryEngine::createMemoryEngine(const QMap<QString, QString>& parameters)

{

    bool anonymous = false;

    QString idValue = parameters.value(QLatin1String("id"));

    if (idValue.isNull() || idValue.isEmpty()) {

        // no store given?  new, anonymous store.

        idValue = QUuid::createUuid().toString();

        anonymous = true;

    }

    } else {

    }

}

/*!

 */

{

}

{

    if (!d->m_refCount.deref()) {

        delete d;

    }

}

/*! \reimp */

QString QContactMemoryEngine::managerName() const

{

}

/*! \reimp */

QMap<QString, QString> QContactMemoryEngine::managerParameters() const

{

    QMap<QString, QString> params;

    params.insert(QLatin1String("id"), d->m_id);

    return params;

}

/*! \reimp */

{

    if (contactId == QContactLocalId(0) || d->m_contactIds.contains(contactId)) {

        QContactLocalId oldId = d->m_selfContactId;

        d->m_selfContactId = contactId;

        return true;

    }

    return false;

}

/*! \reimp */

{

    if (d->m_selfContactId != QContactLocalId(0))

    return d->m_selfContactId;

}

/*! \reimp */

{

    int index = d->m_contactIds.indexOf(contactId);

    if (index != -1) {

        // found the contact successfully.

    }

    return QContact();

}

/*! \reimp */

{

    }

}

{

    // ensure that the contact's details conform to their definitions

    if (!validateContact(*theContact, error)) {

        return false;

    }

    // check to see if this contact already exists

    int index = d->m_contactIds.indexOf(theContact->id().localId());

    if (index != -1) {

        /* We also need to check that there are no modified create only details */

        QContact oldContact = d->m_contacts.at(index);

        if (oldContact.type() != theContact->type()) {

            return false;

        }

        QContactTimestamp ts = theContact->detail(QContactTimestamp::DefinitionName);

        ts.setLastModified(QDateTime::currentDateTime());

        QContactManagerEngine::setDetailAccessConstraints(&ts, QContactDetail::ReadOnly | QContactDetail::Irremovable);

        theContact->saveDetail(&ts);

        // synthesize the display label for the contact.

        // Looks ok, so continue

        d->m_contacts.replace(index, *theContact);

    } else {

        // id does not exist; if not zero, fail.

        QContactId newId;

        newId.setManagerUri(managerUri());

        if (theContact->id() != QContactId() && theContact->id() != newId) {

            // the ID is not empty, and it doesn't identify an existing contact in our database either.

            return false;

        }

        /* New contact */

        QContactTimestamp ts = theContact->detail(QContactTimestamp::DefinitionName);

        ts.setLastModified(QDateTime::currentDateTime());

        ts.setCreated(ts.lastModified());

        setDetailAccessConstraints(&ts, QContactDetail::ReadOnly | QContactDetail::Irremovable);

        theContact->saveDetail(&ts);

        // update the contact item - set its ID

        newId.setLocalId(++d->m_nextContactId);

        theContact->setId(newId);

        // synthesize the display label for the contact.

        // finally, add the contact to our internal lists and return

        d->m_contacts.append(*theContact);                   // add contact to list

        d->m_contactIds.append(theContact->localId());  // track the contact id.

    }

    return true;

}

/*! \reimp */

{

    if(errorMap) {

        errorMap->clear();

    }

    if (!contacts) {

        return false;

    }

    QContactChangeSet changeSet;

    QContact current;

    QContactManager::Error operationError = QContactManager::NoError;

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

        current = contacts->at(i);

        if (!saveContact(&current, changeSet, error)) {

            errorMap->insert(i, operationError);

        } else {

            (*contacts)[i] = current;

        }

    }

    // return false if some error occurred

}

{

    int index = d->m_contactIds.indexOf(contactId);

    if (index == -1) {

        return false;

    }

    // remove the contact from any relationships it was in.

    QContactId thisContact;

    thisContact.setManagerUri(managerUri());

    thisContact.setLocalId(contactId);

        return false;

    }

    // this is meant to be a transaction, so if any of these fail, we're in BIG TROUBLE.

    // a real backend will use DBMS transactions to ensure database integrity.

    // having cleaned up the relationships, remove the contact from the lists.

    d->m_contacts.removeAt(index);

    d->m_contactIds.removeAt(index);

    // and if it was the self contact, reset the self contact id

    if (contactId == d->m_selfContactId) {

        d->m_selfContactId = QContactLocalId(0);

    }

    return true;

}

/*! \reimp */

{

    }

    QContactChangeSet changeSet;

        if (!removeContact(current, changeSet, error)) {

        }

    }

}

/*! \reimp */

{

    QContactId defaultId;

    QList<QContactRelationship> retn;

    for (int i = 0; i < d->m_relationships.size(); i++) {

        QContactRelationship curr = d->m_relationships.at(i);

        // check that the relationship type matches

        if (curr.relationshipType() != relationshipType && !relationshipType.isEmpty())

            continue;

        // if the participantId argument is default constructed, then the relationship matches.

        if (participantId == defaultId) {

            retn.append(curr);

            continue;

        }

        // otherwise, check that the participant exists and plays the required role in the relationship.

            retn.append(curr);

            retn.append(curr);

            retn.append(curr);

        }

    }

    if (retn.isEmpty())

    return retn;

}

{

    // Attempt to validate the relationship.

    // first, check that the source contact exists and is in this manager.

    QString myUri = managerUri();

    if ((!relationship->first().managerUri().isEmpty() && relationship->first().managerUri() != myUri)

        return false;

    }

    // second, check that the second contact exists (if it's local); we cannot check other managers' contacts.

    QContactId dest = relationship->second();

    if (dest.managerUri().isEmpty() || dest.managerUri() == myUri) {

        // this entry in the destination list is supposedly stored in this manager.

        // check that it exists, and that it isn't the source contact (circular)

            return false;

        }

    }

    // the relationship is valid.  We need to update the manager URIs in the second contact if it is empty to our URI.

    if (dest.managerUri().isEmpty()) {

        // need to update the URI

        dest.setManagerUri(myUri);

        relationship->setSecond(dest);

    }

    // check to see if the relationship already exists in the database.  If so, replace.

    // We do this because we don't want duplicates in our lists / maps of relationships.

    QList<QContactRelationship> allRelationships = d->m_relationships;

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

        QContactRelationship curr = allRelationships.at(i);

        if (curr == *relationship) {

            return true;

            // TODO: set error to AlreadyExistsError and return false?

        }

    }

    // no matching relationship; must be new.  append it to lists in our map of relationships where required.

    QList<QContactRelationship> firstRelationships = d->m_orderedRelationships.value(relationship->first().localId());

    QList<QContactRelationship> secondRelationships = d->m_orderedRelationships.value(relationship->second().localId());

    firstRelationships.append(*relationship);

    secondRelationships.append(*relationship);

    d->m_orderedRelationships.insert(relationship->first().localId(), firstRelationships);

    d->m_orderedRelationships.insert(relationship->second().localId(), secondRelationships);

    // finally, insert into our list of all relationships, and return.

    d->m_relationships.append(*relationship);

    return true;

}

/*! \reimp */

{

    QContactManager::Error functionError;

    QContactChangeSet changeSet;

    for (int i = 0; i < relationships->size(); i++) {

        QContactRelationship curr = relationships->at(i);

        // and replace the current relationship with the updated version.

        relationships->replace(i, curr);

        // also, update the total error if it did not succeed.

        if (functionError != QContactManager::NoError)

    }