#include "ut_qtcontacts_common.h"

#include <QContactFetchRequest>

#include <QContactLocalIdFilter>

#include <QContactRemoveRequest>

#include <QContactSaveRequest>

ut_qtcontacts_common::ut_qtcontacts_common()

  : mContactManager(0)

{

}

void ut_qtcontacts_common::initTestCase()

{

}

void ut_qtcontacts_common::cleanupTestCase()

{

}

void ut_qtcontacts_common::init()

{

    QVERIFY(0 == mContactManager);

    mContactManager = new QContactManager("tracker");

    QVERIFY(0 != mContactManager);

}

void ut_qtcontacts_common::cleanup()

{

    if (mContactManager) {

        if (not mLocalIds.isEmpty()) {

#if 0 // FIXME: qtcontacts-tracker doesn't implement QContactRemoveRequest yet

            QContactRemoveRequest request;

            request.setManager(mContactManager);

            request.setContactIds(mLocalIds);

            if (not request.start())

                qDebug() << "error code" << request.error();

            //QVERIFY(request.start());

            waitForRequest(request);

            CHECK_CURRENT_TEST_FAILED;

            QVERIFY(request.isFinished());

            QCOMPARE(request.error(), QContactManager::NoError);

#else

            QMap<int, QContactManager::Error> errors;

            bool success = mContactManager->removeContacts(&mLocalIds, &errors);

            QCOMPARE(mContactManager->error(), QContactManager::NoError);

            QVERIFY(errors.isEmpty());

            QVERIFY(success);

#endif

            mLocalIds.clear();

        }

        mContactManager->deleteLater();

        mContactManager = 0;

    }

}

void ut_qtcontacts_common::waitForRequest(QContactAbstractRequest &request, int ms)

{

    if (request.isFinished())

        return;

    // check pre-conditions

    QCOMPARE((int) request.state(), (int) QContactAbstractRequest::ActiveState);

    // wait for the request to do its work (or get canceled)

    QTime timer;

    timer.start();

    while (request.isActive() && timer.elapsed() < ms) {

        QTest::qWait(10);

    }

    // check post-conditions

    QVERIFY2(not request.isActive(), "timeout expired");

    qDebug() << request.metaObject()->className() << "finished after" << timer.elapsed() << "ms";

}

// FIXME: remove again once QtMobility provides more verbose contact validation utilities

static bool validateContact(QContactManager *manager, const QContact &contact, QContactManager::Error &error_, QString &what)

{

    QList<QString> uniqueDefinitionIds;

    // check that each detail conforms to its definition as supported by this manager.

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

        const QContactDetail& d = contact.details().at(i);

        QVariantMap values = d.variantValues();

        QContactDetailDefinition def = manager->detailDefinition(d.definitionName(), contact.type());

        // check that the definition is supported

        if (def.isEmpty()) {

            error_ = QContactManager::InvalidDetailError;

            what = "Unsupported definition: " + d.definitionName();

            return false;

        }

        // check uniqueness

        if (def.isUnique()) {

            if (uniqueDefinitionIds.contains(def.name())) {

                error_ = QContactManager::AlreadyExistsError;

                what = "Detail must be unique: " + d.definitionName();

                return false;

            }

            uniqueDefinitionIds.append(def.name());

        }

        QList<QString> keys = values.keys();

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

            const QString& key = keys.at(i);

            // check that no values exist for nonexistent fields.

            if (!def.fields().contains(key)) {

                error_ = QContactManager::InvalidDetailError;

                what = "Value for nonexistent field: " + d.definitionName() + "::" + key;

                return false;

            }

            QContactDetailFieldDefinition field = def.fields().value(key);

            // check that the type of each value corresponds to the allowable field type

            if (static_cast<int>(field.dataType()) != values.value(key).userType()) {

                error_ = QContactManager::InvalidDetailError;

                what = "Type doesn't match: " + d.definitionName() + "::" + key;

                return false;

            }

            // check that the value is allowable

            // if the allowable values is an empty list, any are allowed.

            if (!field.allowableValues().isEmpty()) {

                // if the field datatype is a list, check that it contains only allowable values

                if (field.dataType() == QVariant::List || field.dataType() == QVariant::StringList) {

                    QList<QVariant> innerValues = values.value(key).toList();

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

                        if (!field.allowableValues().contains(innerValues.at(i))) {

                            error_ = QContactManager::InvalidDetailError;

                            what = QString("Value not allowed: %1 (%2)").

                                   arg(d.definitionName() + "::" + key,

                                       innerValues.at(i).toString());

                            return false;

                        }

                    }

                } else if (!field.allowableValues().contains(values.value(key))) {

                    // the datatype is not a list; the value wasn't allowed.

                    error_ = QContactManager::InvalidDetailError;

                    what = QString("Value not allowed: %1 (%2)").

                           arg(d.definitionName() + "::" + key,

                               values.value(key).toString());

                    return false;

                }

            }

        }

    }

    return true;

}

void ut_qtcontacts_common::saveContact(QContact &contact, int timeout)

{

    QList<QContact> contactList;

    contactList.append(contact);

    saveContacts(contactList, timeout);

    QCOMPARE(contactList.count(), 1);

    contact = contactList[0];

}

void ut_qtcontacts_common::saveContacts(QList<QContact> &contacts, int timeout)

{

    QVERIFY(not contacts.isEmpty());

    foreach(const QContact &contact, contacts) {

        QContactManager::Error error;

        QString what;

        if (not validateContact(mContactManager, contact, error, what)) {

            foreach(const QContactDetail &d, contact.details()) {

                qDebug() << d.definitionName() << d.variantValues();

            }

            QFAIL(qPrintable(QString("error %1: %2").arg(error).arg(what)));

        }

    }

    // add the contact to database

    QContactSaveRequest request;

    request.setManager(mContactManager);

    request.setContacts(contacts);

    QVERIFY(request.start());

    qDebug() << "saving" << request.contacts().count() << "contacts";

    waitForRequest(request, timeout);

    CHECK_CURRENT_TEST_FAILED;

    // verify the contact got saved

    QVERIFY(request.isFinished());

    QCOMPARE((int) request.error(),

             (int) QContactManager::NoError);

    // copy back the saved contacts

    contacts = request.contacts();

    // remember the local id so that we can remove the contact from database later

    foreach(const QContact &contact, contacts) {

        QVERIFY(contact.localId());

        mLocalIds.append(contact.localId());

    }

}

void ut_qtcontacts_common::fetchContact(const QContactLocalId &id,

                                        QContact &result, int timeout)

{

    QList<QContact> contactList;

    fetchContacts(QList<QContactLocalId>() << id, contactList, timeout);

    QCOMPARE(contactList.count(), 1);

    result = contactList[0];

}

void ut_qtcontacts_common::fetchContact(const QContactFilter &filter,

                                        QContact &result, int timeout)

{

    QList<QContact> contactList;

    fetchContacts(filter, contactList, timeout);

    QCOMPARE(contactList.count(), 1);

    result = contactList[0];

}

void ut_qtcontacts_common::fetchContacts(const QList<QContactLocalId> &ids,

                                         QList<QContact> &result, int timeout)

{

    QContactLocalIdFilter filter;

    filter.setIds(ids);

    fetchContacts(filter, result, timeout);

    CHECK_CURRENT_TEST_FAILED;

    QCOMPARE(result.count(), ids.count());

}

void ut_qtcontacts_common::fetchContacts(const QContactFilter &filter,

                                         QList<QContact> &result, int timeout)

{

    QContactFetchRequest request;

    request.setManager(mContactManager);

    if (QContactFilter::InvalidFilter != filter.type())

        request.setFilter(filter);

    QVERIFY(request.start());

    qDebug() << "fetching contacts";

    waitForRequest(request, timeout);

    CHECK_CURRENT_TEST_FAILED;

    QVERIFY(request.isFinished());

    result = request.contacts();

}

QSet<QString> ut_qtcontacts_common::testSlotNames()

{

    QSet<QString> testSlots;

    for(int i = 0; i < metaObject()->methodCount(); ++i) {

        const QMetaMethod &method = metaObject()->method(i);

        if (QMetaMethod::Private != method.access() ||

            QMetaMethod::Slot != method.methodType()) {

            continue;

        }

        const char *signature = method.signature();

        const char *parenthesis = strchr(signature, '(');

        if (0 != qstrcmp(parenthesis, "()")) {

            continue;

        }

        testSlots.insert(QString::fromLatin1(signature, parenthesis - signature));

    }

    return testSlots;

}