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

**

** 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::saveContactWithPreferredDetails()

{

    QContactManager::Error err;

    //save a contact with preferred details

    QContact c;

    c.setType(QContactType::TypeContact);

    QContactPhoneNumber number1;

    number1.setNumber("123");

    number1.setSubTypes(QContactPhoneNumber::SubTypeMobile);

    c.saveDetail(&number1);

    c.setPreferredDetail("call", number1);

    QContactPhoneNumber number2;

    number2.setNumber("456");

    number2.setSubTypes(QContactPhoneNumber::SubTypeMobile);

    c.saveDetail(&number2);

    c.setPreferredDetail("videocall", number2);

    QContactPhoneNumber number3;

    number3.setNumber("789");

    number3.setSubTypes(QContactPhoneNumber::SubTypeMobile);

    c.saveDetail(&number3);

    c.setPreferredDetail("message", number3);

    QContactEmailAddress email;

    email.setEmailAddress("dummyemail");

    c.saveDetail(&email);

    c.setPreferredDetail("email", email);

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

    QVERIFY(err == QContactManager::NoError);

    //fetch the saved contact and check preferred details

    QContactFetchHint hint = QContactFetchHint();

    QContact fetched = m_engine->contact(c.localId(), hint, &err);

    QVERIFY(err == QContactManager::NoError);

    QContactDetail callDetail1 = fetched.preferredDetail("call");

    QVERIFY(callDetail1.definitionName() == QContactPhoneNumber::DefinitionName);

    QContactPhoneNumber fetchedNumber1 = static_cast<QContactPhoneNumber>(callDetail1);

    QVERIFY(fetchedNumber1.number() == "123");

    QContactDetail callDetail2 = fetched.preferredDetail("videocall");

    QVERIFY(callDetail2.definitionName() == QContactPhoneNumber::DefinitionName);

    QContactPhoneNumber fetchedNumber2 = static_cast<QContactPhoneNumber>(callDetail2);

    QVERIFY(fetchedNumber2.number() == "456");

    QContactDetail callDetail3 = fetched.preferredDetail("message");

    QVERIFY(callDetail3.definitionName() == QContactPhoneNumber::DefinitionName);

    QContactPhoneNumber fetchedNumber3 = static_cast<QContactPhoneNumber>(callDetail3);

    QVERIFY(fetchedNumber3.number() == "789");

    QContactDetail emailDetail = fetched.preferredDetail("email");

    QVERIFY(emailDetail.definitionName() == QContactEmailAddress::DefinitionName);

    QContactEmailAddress fetchedEmail = static_cast<QContactEmailAddress>(emailDetail);

    QVERIFY(fetchedEmail.emailAddress() == "dummyemail");

    //save a contact with one preferred details for several actions

    QContact c2;

    c2.setType(QContactType::TypeContact);

    c2.saveDetail(&number1);

    c2.setPreferredDetail("call", number1);

    c2.setPreferredDetail("videocall", number1);

    c2.setPreferredDetail("message", number1);

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

    QVERIFY(err == QContactManager::NoError);

    //fetch the saved contact and check preferred details

    QContact fetched2 = m_engine->contact(c2.localId(), hint, &err);

    QVERIFY(err == QContactManager::NoError);

    QContactDetail callDetail4 = fetched2.preferredDetail("call");

    QVERIFY(callDetail4.definitionName() == QContactPhoneNumber::DefinitionName);

    QContactPhoneNumber fetchedNumber4 = static_cast<QContactPhoneNumber>(callDetail4);

    QVERIFY(fetchedNumber4.number() == "123");

    QContactDetail callDetail5 = fetched2.preferredDetail("videocall");

    QVERIFY(callDetail5.definitionName() == QContactPhoneNumber::DefinitionName);

    QContactPhoneNumber fetchedNumber5 = static_cast<QContactPhoneNumber>(callDetail5);

    QVERIFY(fetchedNumber5.number() == "123");

    QContactDetail callDetail6 = fetched2.preferredDetail("message");

    QVERIFY(callDetail6.definitionName() == QContactPhoneNumber::DefinitionName);

    QContactPhoneNumber fetchedNumber6 = static_cast<QContactPhoneNumber>(callDetail6);

    QVERIFY(fetchedNumber6.number() == "123");

}

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::retrieveName()

{

    QContactManager::Error err;

    QContactFetchHint hint = QContactFetchHint();

    QStringList hints;

    hints << QContactDisplayLabel::DefinitionName;

    hint.setDetailDefinitionsHint(hints);

    QContact alice;

    alice.setType(QContactType::TypeContact);

    QContactName name;

    name.setFirstName("Alice");

    name.setLastName("Wonders");

    alice.saveDetail(&name);

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

    QVERIFY(err == QContactManager::NoError);

    // Retrieve name of "non contact"

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

    QVERIFY(&c != NULL);

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

    QVERIFY(err == QContactManager::DoesNotExistError);

    // Retrieve name of valid existing contact

    QContactLocalId aid = alice.localId();

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

    QVERIFY(&c != NULL);

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

    QVERIFY(c.displayLabel() == alice.displayLabel());

    QVERIFY(err == QContactManager::NoError);

}