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

**

** Copyright (C) 2010 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 "ut_cntsymbianengine.h"

#include "cntsymbianengine.h"

#include "qcontactrelationship.h"

#include "qcontactrelationshipfilter.h"

#include <qcontactmanager.h>

#include <qcontactdetailfilter.h>

#include <qcontactorganization.h>

#include <qcontactemailaddress.h>

#include <qcontactguid.h>

#include <QtTest/QtTest>

void TestSymbianEngine::initTestCase()

{

    QContactManager::Error error;

    QMap<QString, QString> emptyParameters;

    m_engine = new CntSymbianEngine(emptyParameters, &error);

    if (error == QContactManager::NoError)

        removeAllContacts();

    else

        QSKIP("Error creating manager", SkipAll);

}

void TestSymbianEngine::cleanupTestCase()

{

    removeAllContacts();

    delete m_engine;

}

void TestSymbianEngine::init()

{

}

void TestSymbianEngine::cleanup()

{

    removeAllContacts();

}

void TestSymbianEngine::removeAllContacts()

{

    if(m_engine) {

        // Empty cnt database

        QContactManager::Error err(QContactManager::NoError);

        QList<QContactSortOrder> sortOrders;

        QContactFilter defaultFilter = QContactFilter();

        QList<QContactLocalId> cnts_ids = m_engine->contactIds(defaultFilter, sortOrders, &err);

        QVERIFY(err == QContactManager::NoError);

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

            QVERIFY(m_engine->removeContact(cnts_ids[i], &err));

        }

    }

}

void TestSymbianEngine::ctors()

{

    QContactManager::Error error;

    QMap<QString, QString> params;

    // Ctor

    CntSymbianEngine *ce;

    ce = new CntSymbianEngine(params, &error);

    QVERIFY(ce != NULL);

    QVERIFY(error == QContactManager::NoError);

    if (error == QContactManager::NoError) {

        QVERIFY(ce->managerName() == CNT_SYMBIAN_MANAGER_NAME);

        QVERIFY(ce->m_contactFilter != 0);

        QVERIFY(ce->m_dataBase != 0);

        QVERIFY(ce->m_relationship != 0);

        QVERIFY(ce->m_transformContact != 0);

    } else {

        QSKIP("Error creating CntSymbianEngine in ctor", SkipSingle);

    }

    delete ce;

}

void TestSymbianEngine::saveContact()

{

    QContactManager::Error err;

    QList<QContactSortOrder> sortOrders;

    QContactId empty;

    QContactFilter defaultFilter = QContactFilter();

    int init_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

    QVERIFY(err == QContactManager::NoError);

    // Save a "NULL" contact

    QVERIFY(!m_engine->saveContact(NULL, &err));

    QVERIFY(err == QContactManager::BadArgumentError);

    int current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(init_count == current_count);

    // Save a contact that is not in database

    QContact invaId;

    QVERIFY(m_engine->saveContact(&invaId, &err));   // Add to db

    QVERIFY(err == QContactManager::NoError);

    QContactId cId = invaId.id();

    m_engine->removeContact(invaId.localId(), &err);   // Ensure not in db

    QVERIFY(err == QContactManager::NoError);

    invaId.setId(cId);

    QVERIFY(!m_engine->saveContact(&invaId, &err));   // Update non existent contact

    QVERIFY(err == QContactManager::DoesNotExistError);

    current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(init_count == current_count);

    QContact alice;

    alice.setType("Jargon");

    // Save a "non contact(Jargon) type" contact

    QVERIFY(!m_engine->saveContact(&alice, &err));

    QVERIFY(err == QContactManager::InvalidDetailError);

    QVERIFY(alice.id() == empty);

    QVERIFY(alice.localId() == 0);

    current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(init_count == current_count);

    // Save a valid contact

    alice.setType(QContactType::TypeContact);

    QVERIFY(m_engine->saveContact(&alice, &err));

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(alice.id() != empty);

    QVERIFY(alice.localId() != 0);

    QString uri = QString(QLatin1String(CNT_SYMBIAN_MANAGER_NAME));

    QVERIFY(alice.id().managerUri().contains(uri, Qt::CaseInsensitive));

    current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(init_count + 1 == current_count);

    // Save a valid contact

    QContact g;

    g.setType(QContactType::TypeGroup);

    QContactName en;

    en.setCustomLabel("ccc");

    QVERIFY(g.saveDetail(&en));

    QVERIFY(m_engine->saveContact(&g, &err));

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(g.id() != empty);

    QVERIFY(g.localId() != 0);

    QVERIFY(g.id().managerUri().contains(uri, Qt::CaseInsensitive));

}

void TestSymbianEngine::saveContacts()

{

    QContactManager::Error err;

    QContactFilter defaultFilter = QContactFilter();

    QList<QContactSortOrder> sortOrders;

    QList<QContact> contacts;

    QContactId empty;

    int count = 5;

    int init_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

    QVERIFY(err == QContactManager::NoError);

    // NULL

    QMap<int, QContactManager::Error> errorMap;

    QVERIFY(!m_engine->saveContacts(NULL, &errorMap, &err));

    QVERIFY(errorMap.count() == 0);

    QVERIFY(err == QContactManager::BadArgumentError);

    int current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(init_count == current_count);

    // Save a "non contact(Jargon) type" contacts

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

        QContact alice;

        alice.setType("Jargon");

        contacts.append(alice);

    }

    QVERIFY(!m_engine->saveContacts(&contacts, &errorMap, &err));

    QVERIFY(err == QContactManager::InvalidDetailError);

    foreach(QContactManager::Error err, errorMap) {

        QVERIFY(err == QContactManager::InvalidDetailError);

    }

    foreach(const QContact& c, contacts) {

        QVERIFY(c.id() == empty);

        QVERIFY(c.localId() == 0);

    }

    current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(init_count == current_count);

    contacts.clear();

    // Save valid contacts

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

        QContact alice;

        alice.setType(QContactType::TypeContact);

        contacts.append(alice);

    }

    QVERIFY(m_engine->saveContacts(&contacts, &errorMap, &err));

    QVERIFY(err == QContactManager::NoError);

    foreach(QContactManager::Error err, errorMap) {

        QVERIFY(err == QContactManager::NoError);

    }

    QString uri = QString(QLatin1String(CNT_SYMBIAN_MANAGER_NAME));

    foreach(const QContact& c, contacts) {

        QVERIFY(c.id() != empty);

        QVERIFY(c.localId() != 0);

        QVERIFY(c.id().managerUri().contains(uri, Qt::CaseInsensitive));

    }

    current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(init_count + count == current_count);

    contacts.clear();

    // Save with one invalid contact in list

    init_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

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

        QContact alice;

        alice.setType(QContactType::TypeContact);

        contacts.append(alice);

    }

    QContact invalid;

    invalid.setType("Jasdfasd");

    contacts.insert(3, invalid);

    QVERIFY(!m_engine->saveContacts(&contacts, &errorMap, &err));

    QVERIFY(err == QContactManager::InvalidDetailError);

    foreach(QContactManager::Error err, errorMap) {

        QVERIFY(err == QContactManager::InvalidDetailError);

    }

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

        QContact c = contacts[i];

        if (i == 3) {

            QVERIFY(c.id() == empty);

            QVERIFY(c.localId() == 0);

        } else {

            QVERIFY(c.id() != empty);

            QVERIFY(c.localId() != 0);

            QVERIFY(c.id().managerUri().contains(uri, Qt::CaseInsensitive));

        }

    }

    current_count = m_engine->contactIds(defaultFilter, sortOrders, &err).count();

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(init_count + count == current_count);

    contacts.clear();

}

void TestSymbianEngine::retrieveContact()

{

    QContactManager::Error err;

    QContactFetchHint hint = QContactFetchHint();

    QContact alice;

    alice.setType(QContactType::TypeContact);

    QVERIFY(m_engine->saveContact(&alice, &err));

    QVERIFY(err == QContactManager::NoError);

    // Retrieve "non contact"

    QContact c = m_engine->contact(0, hint, &err);

    QVERIFY(&c != NULL);

    QVERIFY(c.localId() == 0);

    QVERIFY(err == QContactManager::DoesNotExistError);

    // Retrieve valid existing contact

    QContactLocalId aid = alice.localId();

    c = m_engine->contact(aid, hint, &err);

    QVERIFY(&c != NULL);

    QVERIFY(c.localId() == aid);

    QVERIFY(err == QContactManager::NoError);

}

void TestSymbianEngine::retrieveContacts()

{

    QContactManager::Error err;

    QContactFilter f;

    QContactFilter defaultFilter = QContactFilter();

    QContactFetchHint hint = QContactFetchHint();

    QList<QContactSortOrder> s;

    QList<QContactLocalId> cnt_ids;

    QContact c;

    c.setType(QContactType::TypeContact);

    QContactName cn;

    cn.setFirstName("aaa");

    QVERIFY(c.saveDetail(&cn));

    QContactPhoneNumber number;

    number.setContexts("Home");

    number.setSubTypes("Mobile");

    number.setNumber("12345678");

    QVERIFY(c.saveDetail(&number));

    QVERIFY(m_engine->saveContact(&c, &err));

    QVERIFY(err == QContactManager::NoError);

    QContact d;

    d.setType(QContactType::TypeContact);

    QContactName dn;

    dn.setFirstName("bbb");

    QVERIFY(d.saveDetail(&dn));

    QVERIFY(m_engine->saveContact(&d, &err));

    QVERIFY(err == QContactManager::NoError);

    QContact e;

    e.setType(QContactType::TypeGroup);

    QContactName en;

    en.setCustomLabel("ccc");

    QVERIFY(e.saveDetail(&en));

    QVERIFY(m_engine->saveContact(&e, &err));

    QVERIFY(err == QContactManager::NoError);

    // Retrieve all contacts

    cnt_ids = m_engine->contactIds(f, s, &err);

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(cnt_ids.count() > 0);

    QContactDetailFilter mobileFilter;

    mobileFilter.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldSubTypes);

    mobileFilter.setValue(QLatin1String(QContactPhoneNumber::SubTypeMobile));

    // Retrieve contacts with mobile number

    cnt_ids = m_engine->contactIds(mobileFilter, s, &err);

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(cnt_ids.count() > 0);

    // Slow filter

    QList<QContactLocalId> fast_ids = m_engine->contactIds(mobileFilter, s, &err);

    QList<QContactLocalId> all_ids = m_engine->contactIds(f, s, &err);

    QList<QContactLocalId> slow_ids = m_engine->slowFilter(mobileFilter, all_ids, &err);

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(slow_ids.count() == fast_ids.count());

    QContactDetailFilter invalidFilter;

    mobileFilter.setDetailDefinitionName("asfdasdf", "asdfasdf");

    // Retrieve contacts with invalid filter

    cnt_ids = m_engine->contactIds(invalidFilter, s, &err);

    QVERIFY(err == QContactManager::NotSupportedError);

    // Retrieve sorted contacts

    QContactSortOrder sortOrder;

    QList<QContactSortOrder> s1;

    sortOrder.setDetailDefinitionName(QContactName::DefinitionName,  QContactName::FieldFirstName);

    sortOrder.setBlankPolicy(QContactSortOrder::BlanksLast);

    sortOrder.setDirection(Qt::AscendingOrder);

    sortOrder.setCaseSensitivity(Qt::CaseInsensitive);

    s1.append(sortOrder);

    cnt_ids = m_engine->contactIds(defaultFilter, s1, &err);

    QVERIFY(err == QContactManager::NoError);

    // Retrieve with invalid sort order

    QContactSortOrder sortOrder1;

    QList<QContactSortOrder> s2;

    sortOrder1.setDetailDefinitionName("asdfasdf", "asdfasd");

    cnt_ids = m_engine->contactIds(defaultFilter, s2, &err);

    QVERIFY(err == QContactManager::NoError);

    // Retrieve full contacts (with all details)

    QList<QContact> contactList;

    QList<QContactSortOrder> sortOrders;

    QStringList definitionRestrictions;

    contactList = m_engine->contacts(defaultFilter, sortOrders, hint, &err);

    QVERIFY(err == QContactManager::NoError);

    QContactFilter filter;

    contactList = m_engine->contacts(filter, sortOrders, hint, &err);

    QVERIFY(err == QContactManager::NoError);

}

void TestSymbianEngine::updateContact()

{

    QContactManager::Error err;

    QContactFetchHint hint = QContactFetchHint();

    QContact c;

    QVERIFY(m_engine->saveContact(&c, &err));

    QVERIFY(err == QContactManager::NoError);

    int details_before = c.details().count();

    QContactName aliceName;

    aliceName.setFirstName("Alice");

    c.saveDetail(&aliceName);

    QContactPhoneNumber number;

    number.setContexts("Home");

    number.setSubTypes("Mobile");

    number.setNumber("12345678");

    c.saveDetail(&number);

    // update the contact

    QContactLocalId id = c.localId();

    QVERIFY(m_engine->saveContact(&c, &err));

    QVERIFY(err == QContactManager::NoError);

    // Verify that contact has been updated

    QContact d = m_engine->contact(id, hint, &err);

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(d.localId() == id);

    QVERIFY(d.details().count() > details_before);

    QString str = d.detail(QContactPhoneNumber::DefinitionName).definitionName();

    QVERIFY(str == QContactPhoneNumber::DefinitionName);

}

void TestSymbianEngine::updateContactByUid()

{

    QContactManager::Error err;

    QContact c;

    QVERIFY(m_engine->saveContact(&c, &err));

    QVERIFY(err == QContactManager::NoError);

    QContactLocalId initialId = c.localId();

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

    QString uid = guidDetail.guid();

    //clear id

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

    contactId->setLocalId(0);

    contactId->setManagerUri(QString());

    c.setId(*contactId);

    // update the contact   

    QContactName aliceName;

    aliceName.setFirstName("Alice");

    c.saveDetail(&aliceName);

    QContactPhoneNumber number;

    number.setContexts("Home");

    number.setSubTypes("Mobile");

    number.setNumber("12345678");

    c.saveDetail(&number);

    //verify that the same contact was updated

    QVERIFY(m_engine->saveContact(&c, &err));

    QContactLocalId id = c.localId();

    QVERIFY(err == QContactManager::NoError);

    QVERIFY(initialId == id);

}

void TestSymbianEngine::removeContact()

{

    QContactManager::Error err;

    QContactFetchHint hint = QContactFetchHint();

    QContact c;

    c.setType(QContactType::TypeContact);

    QVERIFY(m_engine->saveContact(&c, &err));

    QVERIFY(err == QContactManager::NoError);

    // Remove existing contact

    QContactLocalId id = c.localId();

    QVERIFY(m_engine->removeContact(id, &err));

    QVERIFY(err == QContactManager::NoError);

    // Verify that contact has been removed

    QContact f = m_engine->contact(id, hint, &err);

    QVERIFY(f.localId() == 0);

    QVERIFY(err == QContactManager::DoesNotExistError);

    // Remove non existent contact

    QVERIFY(!m_engine->removeContact(0, &err));

    QVERIFY(err == QContactManager::DoesNotExistError);

}

void TestSymbianEngine::removeContacts()

{

    QContactManager::Error err;

    QContactFetchHint hint = QContactFetchHint();

    QList<QContactLocalId> contacts;

    int count = 5;

    // Remove non existent contacts

    QMap<int, QContactManager::Error> errorMap;

    QVERIFY(!m_engine->removeContacts(contacts, &errorMap, &err));

    QVERIFY(err == QContactManager::BadArgumentError);

    QVERIFY(errorMap.count() == 0);