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

**

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

#include <qtcontacts.h>

#include <QtTracker/ontologies/nie.h>

#include <QtTracker/ontologies/nco.h>

using namespace SopranoLive;

class ConversionLookup: public QHash<QString,QContactPresence::PresenceState>

{

public:

    ConversionLookup& operator<<(const QPair<QString, QContactPresence::PresenceState> &conversion)

    {

        this->insert(conversion.first, conversion.second);

        return *this;

    }

};

const QString FieldQContactLocalId("QContactLocalId");

const QString FieldAccountPath("AccountPath");

const ConversionLookup presenceConversion(ConversionLookup()

            <<QPair<QString, QContactPresence::PresenceState>("presence-status-offline", QContactPresence::PresenceOffline)

            <<QPair<QString, QContactPresence::PresenceState>("presence-status-available", QContactPresence::PresenceAvailable)

            <<QPair<QString, QContactPresence::PresenceState>("presence-status-away", QContactPresence::PresenceAway)

            <<QPair<QString, QContactPresence::PresenceState>("presence-status-extended-away", QContactPresence::PresenceExtendedAway)

            <<QPair<QString, QContactPresence::PresenceState>("presence-status-busy", QContactPresence::PresenceBusy)

            <<QPair<QString, QContactPresence::PresenceState>("presence-status-unknown", QContactPresence::PresenceUnknown)

            <<QPair<QString, QContactPresence::PresenceState>("presence-status-hidden", QContactPresence::PresenceHidden)

            <<QPair<QString, QContactPresence::PresenceState>("presence-status-dnd", QContactPresence::PresenceBusy)

);

void matchPhoneNumber(RDFVariable &variable, QContactDetailFilter &filter)

{

    // This here is the first implementation of filtering that takes into account also affiliations.

    // needs to be applied for other filters too - TODO

    RDFVariable officeContact;

    RDFVariable homeContact;

    RDFVariable rdfPhoneNumber;

    rdfPhoneNumber = homeContact.property<nco::hasPhoneNumber>().property<nco::phoneNumber>();

    RDFVariable rdfOfficePhoneNumber;

    rdfOfficePhoneNumber = officeContact.property<nco::hasAffiliation>().property<nco::hasPhoneNumber>().property<nco::phoneNumber>();

    QString filterValue = filter.value().toString();

    if (filter.matchFlags() == Qt::MatchEndsWith)

    {

        QSettings settings(QSettings::IniFormat, QSettings::UserScope, "Nokia","Trackerplugin");

        int matchDigitCount = settings.value("phoneNumberMatchDigitCount", "7").toInt();

        filterValue = filterValue.right(matchDigitCount);

        qDebug() << "match with:" << matchDigitCount << ":" << filterValue;

        rdfPhoneNumber.hasSuffix(filterValue);

        rdfOfficePhoneNumber.hasSuffix(filterValue);

    }

    else

    {   // default to exact match

        rdfOfficePhoneNumber.matchesRegexp(filterValue);

        rdfPhoneNumber.matchesRegexp(filterValue);

    }

    // This is the key part, including both contacts and affiliations

    variable.isMemberOf(RDFVariableList()<<homeContact);// TODO report bug doesnt work in tracker <<officeContact);

}

/*!

 * To define RDFquery graph for this one is tricky:

 * need to find IMAccount -> hasIMContact -> IMAddress - the same IMAddress as contact \a variable

 * has as PersonContact -> hasIMAddress -> IMAddress

 */

void matchOnlineAccount(RDFVariable &variable, QContactDetailFilter &filter)

{

    if ((filter.matchFlags() & QContactFilter::MatchExactly) == QContactFilter::MatchExactly)

    {

        // \a variable PersonContact -> hasIMAddress -> imaddress

        RDFVariable imaddress = variable.property<nco::hasIMAddress>();

        if (filter.detailFieldName() == "Account" || filter.detailFieldName() == QContactOnlineAccount::FieldAccountUri)

        {

            imaddress.property<nco::imID> ().isMemberOf(QStringList() << filter.value().toString());

        }

        else if (filter.detailFieldName() == FieldAccountPath)

        {

            // need to find IMAccount -> hasIMContact -> imaddress

            RDFVariable imaccount;

            imaccount.property<nco::hasIMContact>() = imaddress;

            imaccount.equal(QUrl(QString("telepathy:")+filter.value().toString()));

        }

        else if (filter.detailFieldName() == QContactOnlineAccount::FieldServiceProvider)

        {

            // need to find IMAccount -> hasIMContact -> imaddress

            RDFVariable imaccount;

            imaccount.property<nco::hasIMContact>() = imaddress;

            imaccount.property<nco::imDisplayName> ().isMemberOf(QStringList() << filter.value().toString());

        }

        else

            qWarning() << "QTrackerContactFetchRequest," << __FUNCTION__

                    << "Unsupported detail filter by QContactOnlineAccount.";

    }

    else

    {

        qWarning() << "QTrackerContactFetchRequest," << __FUNCTION__

                << "Unsupported match flag in detail filter by QContactOnlineAccount. Use QContactFilter::MatchExactly";

    }

}

void matchName(RDFVariable &variable, QContactDetailFilter &filter)

{

    if (filter.detailDefinitionName() != QContactName::DefinitionName) {

        qWarning() << "QTrackerContactFetchRequest," << __FUNCTION__

                   << "Unsupported definition name in detail filter, should be QContactName::DefinitionName";

        return;

    }

    QString filterValue = filter.value().toString();

    QString field = filter.detailFieldName();

    if ((filter.matchFlags() & QContactFilter::MatchExactly) == QContactFilter::MatchExactly) {

        if (field == QContactName::FieldFirstName) {

            variable.property<nco::nameGiven>() = LiteralValue(filterValue);

        } else if (field == QContactName::FieldLastName) {

            variable.property<nco::nameFamily>() = LiteralValue(filterValue);

        } else if (field == QContactName::FieldMiddleName) {

            variable.property<nco::nameAdditional>() = LiteralValue(filterValue);

        } else if (field == QContactName::FieldPrefix) {

            variable.property<nco::nameHonorificPrefix>() = LiteralValue(filterValue);

        } else if (field == QContactName::FieldSuffix) {

            variable.property<nco::nameHonorificSuffix>() = LiteralValue(filterValue);

        }

    } else {

        qWarning() << "QTrackerContactFetchRequest," << __FUNCTION__

                   << "Unsupported match flag in detail filter by QContactName";

    }

}

/*

 * RDFVariable describes all contacts in tracker before filter is applied.

 * This method translates QContactFilter to tracker rdf filter. When query is made

 * after this method, it would return only contacts that fit the filter.

 */

QContactManager::Error QTrackerContactFetchRequest::applyFilterToContact(RDFVariable &variable,

        const QContactFilter &filter)

{

    QContactFetchRequest* r = qobject_cast<QContactFetchRequest*> (req);

    if (!r) {

            return QContactManager::BadArgumentError;

    }

    if (filter.type() == QContactFilter::LocalIdFilter) {

        QContactLocalIdFilter filt = filter;

        if (!filt.ids().isEmpty()) {

            if (!isMeContact(r->filter())) {

            variable.property<nco::contactUID>().isMemberOf(filt.ids());

            } else {

                variable == nco::default_contact_me::iri();

            }

        } else {

            qWarning() << Q_FUNC_INFO << "QContactLocalIdFilter idlist is empty";

            return QContactManager::BadArgumentError;

        }

    } else if (filter.type() == QContactFilter::ContactDetailFilter) {

        // this one is tricky as we need to match in contacts or in affiliations

        QContactDetailFilter filt = filter;

        if ( QContactPhoneNumber::DefinitionName == filt.detailDefinitionName()

             && QContactPhoneNumber::FieldNumber == filt.detailFieldName()) {

            matchPhoneNumber(variable, filt);

        }

        else if(QContactOnlineAccount::DefinitionName == filt.detailDefinitionName())

        {

            matchOnlineAccount(variable, filt);

        }

        else if (QContactName::DefinitionName == filt.detailDefinitionName()) {

            matchName(variable, filt);

        }

        else if (filt.matchFlags() == Qt::MatchExactly) {

            if (QContactEmailAddress::DefinitionName == filt.detailDefinitionName()

                       && QContactEmailAddress::FieldEmailAddress == filt.detailFieldName()) {

                RDFVariable rdfEmailAddress;

                rdfEmailAddress = variable.property<nco::hasEmailAddress>();

                rdfEmailAddress.property<nco::emailAddress>() = LiteralValue(filt.value().toString());

            } else {

                qWarning() << __PRETTY_FUNCTION__ << "QContactTrackerEngine: Unsupported QContactFilter::ContactDetail"

                    << filt.detailDefinitionName();

                return QContactManager::NotSupportedError;

            }

        }

    }

    else if (filter.type() == QContactFilter::ContactDetailRangeFilter)

    {

        return applyDetailRangeFilterToContact(variable, filter);

    }

    else if (filter.type() == QContactFilter::ChangeLogFilter) {

        const QContactChangeLogFilter& clFilter = static_cast<const QContactChangeLogFilter&>(filter);

        // do not return facebook and telepathy contacts here

        // it is a temp implementation for the what to offer to synchronization constraint

        variable.property<nao::hasTag>().property<nao::prefLabel>() = LiteralValue("addressbook");

        if (clFilter.eventType() == QContactChangeLogFilter::EventRemoved) { // Removed since

            qWarning() << "QContactTrackerEngine: Unsupported QContactChangeLogFilter::Removed (contacts removed since)";

            return QContactManager::NotSupportedError;

        } else if (clFilter.eventType() == QContactChangeLogFilter::EventAdded) { // Added since

            variable.property<nie::contentCreated>() >= LiteralValue(clFilter.since().toString(Qt::ISODate));

        } else if (clFilter.eventType() == QContactChangeLogFilter::EventChanged) { // Changed since

            variable.property<nie::contentLastModified>() >= LiteralValue(clFilter.since().toString(Qt::ISODate));

        }

    } else if (filter.type() == QContactFilter::UnionFilter) {

        const QContactUnionFilter unionFilter(filter);

        foreach (const QContactFilter& f, unionFilter.filters()) {

            QContactManager::Error error = applyFilterToContact(variable, f);

            if (QContactManager::NoError != error)

                return error;

        }

    }

    else if(filter.type() == QContactFilter::InvalidFilter || filter.type() == QContactFilter::DefaultFilter)

        return QContactManager::NoError;

    else

        return QContactManager::NotSupportedError;

    return QContactManager::NoError;

}

//!\sa applyFilterToContact

QContactManager::Error QTrackerContactFetchRequest::applyDetailRangeFilterToContact(RDFVariable &variable, const QContactFilter &filter)

{

    Q_ASSERT(filter.type() == QContactFilter::ContactDetailRangeFilter);

    if (filter.type() == QContactFilter::ContactDetailRangeFilter) {

        QContactDetailRangeFilter filt = filter;

        // birthday range

        if (QContactBirthday::DefinitionName == filt.detailDefinitionName()

                && QContactBirthday::FieldBirthday == filt.detailFieldName())

        {

            RDFVariable time = variable.property<nco::birthDate>();

            if (filt.rangeFlags() & QContactDetailRangeFilter::IncludeUpper)

                time <= LiteralValue(filt.maxValue().toDateTime().toString(Qt::ISODate));

            else

                time < LiteralValue(filt.maxValue().toDateTime().toString(Qt::ISODate));

            if (filt.rangeFlags() & QContactDetailRangeFilter::ExcludeLower)

                time > LiteralValue(filt.minValue().toDateTime().toString(Qt::ISODate));

            else

                time >= LiteralValue(filt.minValue().toDateTime().toString(Qt::ISODate));

            return QContactManager::NoError;

        }

    }

    qWarning() << __PRETTY_FUNCTION__ << "Unsupported detail range filter";

    return QContactManager::NotSupportedError;

}

/*

 * To understand why all the following methods have for affiliation param, check nco ontology:

 * every contact has all these properties and also linked to affiliations (also contacts - nco:Role)

 * that again have the same properties. So it was needed to make the same query 2-ce - once for contact

 * and once for affiliations

 */

RDFSelect preparePhoneNumbersQuery(RDFVariable &rdfcontact1, bool forAffiliations)

{

    RDFVariable phone;

    if (!forAffiliations)

        phone = rdfcontact1.property<nco::hasPhoneNumber>();

    else

        phone = rdfcontact1.property<nco::hasAffiliation>().property<nco::hasPhoneNumber>();

    RDFVariable type = phone.type();

    type.property<rdfs::subClassOf>().notEqual(nco::ContactMedium::iri()); // sparql cannot handle exact type but returns all super types as junk rows

    type.property<rdfs::subClassOf>().notEqual(rdfs::Resource::iri()); // sparql cannot handle exact type but returns all super types as junk rows

    // therefore we eliminate those rows that are not of interest

    // columns

    RDFSelect queryidsnumbers;

    queryidsnumbers.addColumn("contactId", rdfcontact1.property<nco::contactUID> ());

    queryidsnumbers.addColumn("phoneno", phone.property<nco::phoneNumber> ());

    queryidsnumbers.addColumn("type", type);

    queryidsnumbers.distinct();

    return queryidsnumbers;

}

RDFSelect prepareEmailAddressesQuery(RDFVariable &rdfcontact1, bool forAffiliations)

{

    RDFVariable email;

    if (!forAffiliations)

        email = rdfcontact1.property<nco::hasEmailAddress>();

    else

        email = rdfcontact1.property<nco::hasAffiliation>().property<nco::hasEmailAddress>();

    const RDFVariable& type = email.type();

    type.property<rdfs::subClassOf>().notEqual(nco::Resource::iri()); // sparql cannot handle exact type but returns all super types as junk rows

    // therefore we eliminate those rows that are not of interest

    // columns

    RDFSelect queryidsnumbers;

    queryidsnumbers.addColumn("contactId", rdfcontact1.property<nco::contactUID> ());

    queryidsnumbers.addColumn("emailaddress", email.property<nco::emailAddress> ());

    rdfcontact1.property<nco::hasEmailAddress> ().isOfType( nco::EmailAddress::iri(), true);

    queryidsnumbers.addColumn("type", type);

    queryidsnumbers.distinct();

    return queryidsnumbers;

}

/*!

 * \a contact here describes rdf graph - when making query, depending on filters applied

 * to \a contact, query results to any set of contacts

 */

RDFSelect prepareIMAddressesQuery(RDFVariable  &contact)

{

    RDFSelect queryidsimacccounts;

    // this establishes query graph relationship: imaddress that we want is a property in contact

    RDFVariable imaddress = contact.property<nco::hasIMAddress>();

    contact != nco::default_contact_me::iri();

    // in the query, we need to get imaccount where this imaddress resides.

    // i.e. from which local account we have established connection to imaddress

    RDFVariable imaccount = RDFVariable::fromType<nco::IMAccount>();

    // define link between imaccount to imaddress.

    imaccount.property<nco::hasIMContact>() = imaddress;

    queryidsimacccounts.addColumn("imaddress", imaddress);

    queryidsimacccounts.addColumn("contactId", contact.property<nco::contactUID> ());

    queryidsimacccounts.groupBy(imaddress);

    queryidsimacccounts.addColumn("IMId", imaddress.property<nco::imID> ());

    queryidsimacccounts.addColumn("status", imaddress.optional().property<nco::imPresence> ());

    queryidsimacccounts.addColumn("message", imaddress.optional().property<nco::imStatusMessage> ());

    queryidsimacccounts.addColumn("nick", imaddress.optional().property<nco::imNickname> ());

    queryidsimacccounts.addColumn("type", imaccount); // account path

    queryidsimacccounts.addColumn("capabilities",

              imaddress.optional().property<nco::imCapability>().filter("GROUP_CONCAT", LiteralValue(",")));

    queryidsimacccounts.addColumn("serviceprovider", imaccount.property<nco::imDisplayName>());

    return queryidsimacccounts;

}

RDFSelect prepareIMAccountsQuery(RDFVariable  &contact)

{

    RDFVariable imAccount;

    imAccount = RDFVariable::fromType<nco::IMAccount>();

    RDFSelect queryidsimaccounts;

    RDFVariable address = imAccount.property<nco::imAccountAddress>();

    queryidsimaccounts.addColumn("uri", contact);

    queryidsimaccounts.addColumn("presence", address.property<nco::imPresence>());

    queryidsimaccounts.addColumn("message", address.property<nco::imStatusMessage>());

    queryidsimaccounts.addColumn("nick", address.property<nco::imNickname>());

    queryidsimaccounts.addColumn("distinct ", address.property<nco::imID>());

    queryidsimaccounts.addColumn("address_uri", address);

    queryidsimaccounts.addColumn("photo",address.optional().property<nco::imAvatar>());

    return queryidsimaccounts;

}

QTrackerContactAsyncRequest::QTrackerContactAsyncRequest(QContactAbstractRequest* request)

: req(request)

{

}

const QString rdfPhoneType2QContactSubtype(const QString rdfPhoneType)

{

    if( rdfPhoneType.endsWith("VoicePhoneNumber") )

        return QContactPhoneNumber::SubTypeVoice;

    else if ( rdfPhoneType.endsWith("CarPhoneNumber") )

        return QContactPhoneNumber::SubTypeCar;

    else if ( rdfPhoneType.endsWith("CellPhoneNumber") )

        return QContactPhoneNumber::SubTypeMobile;

    else if ( rdfPhoneType.endsWith("BbsPhoneNumber") )

        return QContactPhoneNumber::SubTypeBulletinBoardSystem;

    else if ( rdfPhoneType.endsWith("FaxNumber") )

        return QContactPhoneNumber::SubTypeFax;

    else if ( rdfPhoneType.endsWith("ModemNumber") )

        return QContactPhoneNumber::SubTypeModem;

    else if ( rdfPhoneType.endsWith("PagerNumber") )

        return QContactPhoneNumber::SubTypePager;

    else if ( rdfPhoneType.endsWith("MessagingNumber") )

        return QContactPhoneNumber::SubTypeMessagingCapable;

    else

        qWarning() << Q_FUNC_INFO << "Not handled phone number type:" << rdfPhoneType;

    return "";

}

QTrackerContactAsyncRequest::~QTrackerContactAsyncRequest()

{

}

/*!

 * The method was initially created to add default fields in case client did not supply

 * fields constraint - in that case the constraint is that default contact fields (ones

 * being edited in contact card and synchronized) are queried.

 */

void QTrackerContactFetchRequest::validateRequest()

{

    Q_ASSERT(req);

    Q_ASSERT(req->type() == QContactAbstractRequest::ContactFetchRequest);

    QContactFetchRequest* r = qobject_cast<QContactFetchRequest*> (req);

    QContactFetchHint fetchHint = r->fetchHint();

    if (r && fetchHint.detailDefinitionsHint().isEmpty()) {

        QStringList definitionNames;

        definitionNames << QContactAvatar::DefinitionName

            << QContactBirthday::DefinitionName

            << QContactAddress::DefinitionName

            << QContactEmailAddress::DefinitionName

            << QContactGender::DefinitionName

            << QContactAnniversary::DefinitionName

            << QContactName::DefinitionName

            << QContactOnlineAccount::DefinitionName

            << QContactOrganization::DefinitionName

            << QContactPhoneNumber::DefinitionName

            << QContactUrl::DefinitionName;

        fetchHint.setDetailDefinitionsHint(definitionNames);

        r->setFetchHint(fetchHint);

    }

}

QTrackerContactFetchRequest::QTrackerContactFetchRequest(QContactAbstractRequest* request,

                                                         QContactManagerEngine* parent) :

    QObject(parent),QTrackerContactAsyncRequest(request),

    queryPhoneNumbersNodesPending(0),

    queryEmailAddressNodesPending(0)

{

    Q_ASSERT(parent);

    Q_ASSERT(request);

    QContactManagerEngine::updateRequestState(req, QContactAbstractRequest::ActiveState);

    QTimer::singleShot(0, this, SLOT(run()));

}

void QTrackerContactFetchRequest::run()

{

    validateRequest();

    QContactFetchRequest* r = qobject_cast<QContactFetchRequest*> (req);

    QContactFetchHint fetchHint = r->fetchHint();

    QStringList definitionNames = fetchHint.detailDefinitionsHint();

    RDFVariable RDFContact = RDFVariable::fromType<nco::PersonContact>();

    QContactManager::Error error = applyFilterToContact(RDFContact, r->filter());

    if (error != QContactManager::NoError)

    {

        emitFinished(error);

        return;

    }

    if (definitionNames.contains(QContactPhoneNumber::DefinitionName)) {

        queryPhoneNumbersNodes.clear();

        queryPhoneNumbersNodesPending = 2;

        for(int forAffiliations = 0; forAffiliations <= 1; forAffiliations++) {

            // prepare query to get all phone numbers

            RDFVariable rdfcontact1 = RDFVariable::fromType<nco::PersonContact>();

            applyFilterToContact(rdfcontact1, r->filter());

            // criteria - only those with phone numbers

            RDFSelect queryidsnumbers = preparePhoneNumbersQuery(rdfcontact1, forAffiliations);

            queryPhoneNumbersNodes << ::tracker()->modelQuery(queryidsnumbers);

            // need to store LiveNodes in order to receive notification from model

            QObject::connect(queryPhoneNumbersNodes[forAffiliations].model(),

                             SIGNAL(modelUpdated()), this, SLOT(phoneNumbersReady()));

        }

    }

    if (definitionNames.contains(QContactEmailAddress::DefinitionName)) {

        queryEmailAddressNodes.clear();

        queryEmailAddressNodesPending = 2;

        for(int forAffiliations = 0; forAffiliations <= 1; forAffiliations++) {

            // prepare query to get all email addresses

            RDFVariable rdfcontact1 = RDFVariable::fromType<nco::PersonContact>();

            applyFilterToContact(rdfcontact1, r->filter());

            // criteria - only those with email addresses

            RDFSelect queryidsnumbers = prepareEmailAddressesQuery(rdfcontact1,forAffiliations);

            queryEmailAddressNodes << ::tracker()->modelQuery(queryidsnumbers);

            // need to store LiveNodes in order to receive notification from model

            QObject::connect(queryEmailAddressNodes[forAffiliations].model(),

                             SIGNAL(modelUpdated()), this, SLOT(emailAddressesReady()));

        }

    }

    if (definitionNames.contains( QContactOnlineAccount::DefinitionName)) {

        queryIMAccountNodesPending = 1;

        RDFSelect queryidsimaccounts;

        if(isMeContact(r->filter())) {

            // Prepare a query to get all IMAccounts

            RDFVariable meContact = RDFVariable::fromInstance<nco::default_contact_me>();

            queryidsimaccounts = prepareIMAccountsQuery(meContact);

        } else {

            RDFVariable rdfIMContact;

            rdfIMContact = rdfIMContact.fromType<nco::PersonContact> ();

            applyFilterToContact(rdfIMContact, r->filter());

            queryidsimaccounts = prepareIMAddressesQuery(rdfIMContact);

        }

        queryIMAccountNodes = ::tracker()->modelQuery(queryidsimaccounts);

        QObject::connect(queryIMAccountNodes.model(),

                SIGNAL(modelUpdated()), SLOT(iMAcountsReady()));

    }

    QList<QContactLocalId> ids;

    RDFVariable RDFContact1 = RDFVariable::fromType<nco::PersonContact>();

    applyFilterToContact(RDFContact1, r->filter());

    RDFSelect quer;