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

**

** 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 <QApplication>

#include <QtTest/QtTest>

//#include "contact.h"

//#include <QContactManager>

#include <QDebug>

#include <QEventLoop>

#include <QTimer>

#include <qcontactabstractrequest.h>

#include <requests/qcontactfetchrequest.h>

#include <filters/qcontactlocalidfilter.h>

#include <details/qcontactdetails.h>

#ifdef Q_OS_SYMBIAN

#include <cntfilt.h>

#include <cntitem.h>

#include <cntdb.h>

#include <cntitem.h>

#include <cntfield.h>

#include <cntfldst.h>

#include <cntdef.h>

#include <cntdef.hrh> 

#endif

QTM_USE_NAMESPACE

class tst_Contact : public QObject

{

    Q_OBJECT

public:

    enum platform {

        QContacts,

        Native

    };

private slots:

    void initTestCase();

    void cleanupTestCase();

    void tst_createTime_data();

    void tst_createTime();

    void tst_fetchAllContactIds_data();

    void tst_fetchAllContactIds();

    void tst_fetchOneContact_data();

    void tst_fetchOneContact();

    void tst_fetchTenContact_data();

    void tst_fetchTenContact();

    //void tst_fetchAllContact();

    void tst_createContact_data();  

    void tst_createContact();

    void tst_saveContact_data();

    void tst_saveContact();    

    void tst_nameFilter_data();

    void tst_nameFilter();

    void tst_removeOneContact_data();

    void tst_removeOneContact();

    void tst_removeAllContacts_data();

    void tst_removeAllContacts();

//    void tst_currentLanguage();

//    void tst_availableLanguages();

//

//    void tst_versions_data();

//    void tst_versions();

//

//    void tst_hasFeatures_data();

//    void tst_hasFeatures();

public slots:

    void gotContact(QContactFetchRequest*,bool);

    void stateChanged(QContactAbstractRequest::State newState);

    void timeout();

    void resultsAvailable();

    void resultsAvailableFilter();

    //void setManager(QContactManager *mgr);

private:

    void createContact(QContactManager *mgr, enum platform p = QContacts);

    void clearContacts(QContactManager *mgr, enum platform p = QContacts);

    int countContacts(QContactManager *mgr, enum platform p = QContacts);

    QString manager;

    QEventLoop *loop;

//    QContactManager *m_qm;

    QContactManager *m_systemManager;

    QList<QContactManager *> m_managers;

//    enum platform m_platform;

    int m_num_contacts;

    QList<QContactLocalId> id_list;

    int m_run;

    int m_num_start;

    QTimer *m_timer;

    QStringList firstNames;

    QStringList lastNames;    

};

Q_DECLARE_METATYPE(QContactManager *);

Q_DECLARE_METATYPE(tst_Contact::platform);

void tst_Contact::initTestCase()

{    

    qDebug() << "Managers: " << QContactManager::availableManagers();    

    m_run = 0;

    m_systemManager = 0x0;

    QStringList list = QContactManager::availableManagers();       

    while(!list.empty()){

      QString mgr = list.takeFirst();

      if((mgr != "invalid") && (mgr != "testdummy") && (mgr != "maliciousplugin")){

        m_managers.append(new QContactManager(mgr));

        if((mgr == "symbian") || (mgr == "tracker") || (mgr == "maemo5")) {

          qDebug() << "Found system manager: " << mgr;

          m_systemManager = m_managers.last();

        }

        if(!m_systemManager && mgr == "memory"){

            qDebug() << "Found system manager of last resort: " << mgr;

            m_systemManager = m_managers.last();

        }

      }      

    }

    if(m_managers.isEmpty()) {

      QFAIL("Unable to find valid managers. Please check install");

    }

    if(!m_systemManager){

      QFAIL("Unable to find a default plugin to use, please install plugins or fix test");

    }

    // setup an event loop for waiting

    loop = new QEventLoop;

    firstNames << "Anahera" << "Anaru" << "Hemi" << "Hine" << "Kiri" << "Maata" << "Mere" << "Moana" << "Paora" << "Petera" << "Piripi" << "Ruiha" << "Tane" << "Whetu";

    lastNames << "Ati Awa" << "Kai Taho" << "Moriori" << "Muaupoko" << "Nga Rauru" << "Taranaki" << "Opotoki" << "Aotea" << "Taninui" << "Tuhourangi" << "Tainui" << "Waitaha";

    m_num_start = countContacts(m_systemManager);

    qDebug() << "Number of Contact: " << m_num_start;

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

      foreach(QContactManager *mgr, m_managers){

        createContact(mgr);

      }

    }

    int after = countContacts(m_systemManager);

    if(after - m_num_start != 20){

        qWarning() << "Failed to create 20 contacts";

    }

    m_timer = new QTimer(this);

    connect(m_timer, SIGNAL(timeout()), this, SLOT(timeout()));

}

int tst_Contact::countContacts(QContactManager *manager, enum platform platform)

{  

  if(platform == tst_Contact::QContacts) {

        QList<QContactLocalId> qcl = manager->contactIds();

        return qcl.count();

  } 

  else if(platform == tst_Contact::Native){ 

#ifdef Q_OS_SYMBIAN

    CContactDatabase* contactsDb = CContactDatabase::OpenL();

    CleanupStack::PushL(contactsDb);

    int num = contactsDb->CountL();

    CleanupStack::PopAndDestroy(contactsDb);

    return num;    

#endif

    }

    qWarning("No backend support in countContacts()");

    return 0;

}

void tst_Contact::cleanupTestCase()

{

  foreach(QContactManager *manager, m_managers) {

    clearContacts(manager);          

  }

  if(countContacts(0x0, Native))

    clearContacts(0x0, tst_Contact::Native);

  int num_end = countContacts(0x0, tst_Contact::Native);  

  if(num_end){

    qWarning() << "Ended with: " << num_end << " contacts, should be 0";

  }

}

void tst_Contact::createContact(QContactManager *manager, enum platform platform)

{

  if(platform == tst_Contact::QContacts) {    

    QContact *c = new QContact;

    c->setType(QContactType::TypeContact);

    QContactName cname;

    QString name;

    name = firstNames.takeFirst();

    firstNames.push_back(name);

    cname.setFirstName(name);

    name = lastNames.takeFirst();

    lastNames.push_back(name);

    cname.setLastName(name);

#ifndef Q_WS_MAEMO_5

    cname.setPrefix("Mr");

#endif

    c->saveDetail(&cname);

    if(!manager->saveContact(c)){

      qDebug() << "Failed to create contact during setup";

      return;

    }

    id_list.append(c->localId());

    delete c;

  }

  else if(platform == tst_Contact::Native){

#ifdef Q_OS_SYMBIAN

    // Create a contact card and add a work phone number. Numeric values are 

    // stored in a text field (storage type = KStorageTypeText).

    CContactDatabase* db = CContactDatabase::OpenL();

    CleanupStack::PushL(db);

    CContactCard* newCard = CContactCard::NewLC();    

    QString name;

    // Create the firstName field and add the data to it

    name = firstNames.takeFirst();

    firstNames.push_back(name);        

    CContactItemField* firstName = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldGivenName);

    TPtrC Firstname(reinterpret_cast<const TUint16*>(name.utf16()));

    firstName->TextStorage()->SetTextL(Firstname);      

    newCard->AddFieldL(*firstName);

    CleanupStack::Pop(firstName);

    // Create the lastName field and add the data to it

    name = lastNames.takeFirst();

    lastNames.push_back(name);        

    CContactItemField* lastName= CContactItemField::NewLC(KStorageTypeText, KUidContactFieldFamilyName);

    TPtrC Lastname(reinterpret_cast<const TUint16*>(name.utf16()));

    lastName->TextStorage()->SetTextL(Lastname);

    newCard->AddFieldL(*lastName);

    CleanupStack::Pop(lastName);

    CContactItemField* prefix = CContactItemField::NewLC(KStorageTypeText, KUidContactFieldPrefixName);

    _LIT(KPrefix, "Mr");

    prefix->TextStorage()->SetTextL(KPrefix);

    newCard->AddFieldL(*prefix);

    CleanupStack::Pop(prefix);

    // Add newCard to the database

    const TContactItemId contactId = db->AddNewContactL(*newCard);

    db->CloseContactL(contactId);    

    id_list.append(contactId);

    CleanupStack::PopAndDestroy(2, db); //newCard, contactsDb

#else

    qWarning("No native test for createContact");

#endif 

  }

}

void tst_Contact::clearContacts(QContactManager *manager, enum platform platform)

{

  if(platform == tst_Contact::QContacts) {

    QMap<int, QContactManager::Error> errorMap;

    manager->removeContacts(id_list, &errorMap);

    id_list.clear();

  }

  else if(platform == tst_Contact::Native){

#ifdef Q_OS_SYMBIAN

    CContactDatabase* contactDb = CContactDatabase::OpenL();

    CleanupStack::PushL(contactDb);

    CCntFilter *filter = CCntFilter::NewL();

    CleanupStack::PushL(filter);

    //get all contact items (no groups, templates...)

    filter->SetContactFilterTypeALL(EFalse);

    filter->SetContactFilterTypeCard(ETrue);

    TRAPD(err, contactDb->FilterDatabaseL(*filter));

    if(err != KErrNone){

      qWarning() << "clearContacts failed to get any contacts error: " << err;

      CleanupStack::PopAndDestroy(2, contactDb);

      return;

    }

    CContactIdArray *iContacts = 0;

    TRAP(err, iContacts = CContactIdArray::NewL(filter->iIds));

    if(err != KErrNone){      

      CleanupStack::PopAndDestroy(2, contactDb); //idArray, contactsDb

      return;

    }

    CleanupStack::PushL(iContacts);

    TRAP(err, contactDb->DeleteContactsL(*iContacts));

    if(err != KErrNone)

      qWarning() << "DeleteContacts failed with: " << err;

    CleanupStack::PopAndDestroy(3, contactDb); //idArray, contactsDb

#endif

  }

}

void tst_Contact::tst_createTime_data()

{

  QTest::addColumn<tst_Contact::platform>("platform");

  QTest::addColumn<QContactManager *>("manager");

  QTest::newRow("Native") << tst_Contact::Native << (QContactManager *)0x0;

  foreach(QContactManager *mgr, m_managers){

    QTest::newRow(QString("QContact-" + mgr->managerName()).toAscii()) << tst_Contact::QContacts << mgr; 

  }  

}

void tst_Contact::tst_createTime()

{

  QFETCH(tst_Contact::platform, platform);

  QFETCH(QContactManager *, manager);

  if(platform == tst_Contact::QContacts){

    QContactManager *qm = 0x0;

    QBENCHMARK {

        qm = new QContactManager(manager->managerName());

    }

    delete qm;

  }

  else if(platform == tst_Contact::Native){

#ifdef Q_OS_SYMBIAN

    CContactDatabase* db = 0x0;

    QBENCHMARK {

      db = CContactDatabase::OpenL();     

    }

    CleanupStack::PushL(db);

    CleanupStack::PopAndDestroy(db); //db

#endif

  }

}

void tst_Contact::tst_fetchAllContactIds_data()

{

  QTest::addColumn<tst_Contact::platform>("platform");

  QTest::addColumn<QContactManager *>("manager");

  QTest::newRow("Native") << tst_Contact::Native << (QContactManager *)0x0;

  foreach(QContactManager *mgr, m_managers){

    QTest::newRow(QString("QContact-" + mgr->managerName()).toAscii()) << tst_Contact::QContacts << mgr; 

  }  

}

void tst_Contact::tst_fetchAllContactIds()

{   

  QFETCH(tst_Contact::platform, platform);

  QFETCH(QContactManager *, manager);

  if(platform == tst_Contact::QContacts) {

    QList<QContactLocalId> ql;    

    QBENCHMARK {

        ql = manager->contactIds();

    }        

  }

  else if(platform == tst_Contact::Native){

#ifdef Q_OS_SYMBIAN

    //open database

    // Open the default contact database

    CContactDatabase* contactsDb = CContactDatabase::OpenL();

    CleanupStack::PushL(contactsDb);    

    CCntFilter *filter = CCntFilter::NewLC();

    //get all contact items (no groups, templates...)

    filter->SetContactFilterTypeALL(EFalse);

    filter->SetContactFilterTypeCard(ETrue);

    QBENCHMARK {

      contactsDb->FilterDatabaseL(*filter);

      CContactIdArray *iContacts = CContactIdArray::NewLC(filter->iIds);

      CleanupStack::PopAndDestroy(iContacts);

    }

    CleanupStack::PopAndDestroy(2, contactsDb); //iContacts, filter, contactsDb    

#endif 

  }

}

void tst_Contact::tst_fetchOneContact_data()

{

  QTest::addColumn<tst_Contact::platform>("platform");

  QTest::addColumn<QContactManager *>("manager");

  QTest::newRow("Native") << tst_Contact::Native << (QContactManager *)0x0;

  foreach(QContactManager *mgr, m_managers){

    QTest::newRow(QString("QContact-" + mgr->managerName()).toAscii()) << tst_Contact::QContacts << mgr; 

  }  

}

void tst_Contact::tst_fetchOneContact()

{

  QFETCH(tst_Contact::platform, platform);

  QFETCH(QContactManager *, manager);

  if(platform == tst_Contact::QContacts){

    QContact c;    

    m_run++;

#if defined(Q_WS_MAEMO_6)

    int ret;   

    QContactFetchRequest* req = new QContactFetchRequest;

    QList<QContactLocalId> qcl = manager->contactIds();

    if(qcl.count() < 1)

        QFAIL("No contacts to pull from tracker");

    QList<QContactLocalId> one;

    one += qcl.takeFirst();

    QContactLocalIdFilter idFil;

    idFil.setIds(one);

    req->setFilter(idFil);

    req->setManager(manager);    

    //connect(req, SIGNAL(progress(QContactFetchRequest*, bool)), this, SLOT(gotContact(QContactFetchRequest*,bool)));

    //connect(req, SIGNAL(stateChanged(QContactAbstractRequest::State)), this, SLOT(stateChanged(QContactAbstractRequest::State)));

    connect(req, SIGNAL(resultsAvailable()), this, SLOT(resultsAvailable()));

    m_num_contacts = 1;

    m_timer->start(1000);

    QBENCHMARK {

        req->start();

        ret = loop->exec();

    }

    m_timer->stop();

    //qDebug() << "Got Contact: " << qm->synthesizeDisplayLabel(c);

    if(ret){

        QFAIL("Failed to load one contact");

    }

    delete req;

#elif defined(Q_OS_SYMBIAN)    

    QList<QContactLocalId> qcl = manager->contactIds();    

    if(qcl.count() < 1)

        QFAIL("No contacts to pull from tracker");

    QBENCHMARK {

       c = manager->contact(qcl.first());

    }

#endif

  }

  else if(platform == tst_Contact::Native){

#ifdef Q_OS_SYMBIAN

    //open database

    // Open the default contact database

    CContactDatabase* contactDb = CContactDatabase::OpenL();

    CleanupStack::PushL(contactDb);       

    CContactItem *item = 0;

    TInt r;

    CCntFilter *filter = CCntFilter::NewL();

    CleanupStack::PushL(filter);

    //get all contact items (no groups, templates...)

    filter->SetContactFilterTypeALL(EFalse);

    filter->SetContactFilterTypeCard(ETrue);

    contactDb->FilterDatabaseL(*filter);

    CContactIdArray *iContacts = CContactIdArray::NewL(filter->iIds);

    CleanupStack::PushL(iContacts);

    int cnt = iContacts->Count();

    int i = 0;

    QBENCHMARK {