/*

* Copyright (C) 2013 Jolla Mobile <matthew.vogt@jollamobile.com>

*

* You may use this file under the terms of the BSD license as follows:

*

* "Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are

* met:

* * Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* * Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in

* the documentation and/or other materials provided with the

* distribution.

* * Neither the name of Nemo Mobile nor the names of its contributors

* may be used to endorse or promote products derived from this

* software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."

*/

#include "seasideimport.h"

#include "seasidecache.h"

#include <QContactDetailFilter>

#include <QContactFetchHint>

#include <QContactManager>

#include <QContactSortOrder>

#include <QContactSyncTarget>

#include <QContactAddress>

#include <QContactAnniversary>

#include <QContactAvatar>

#include <QContactBirthday>

#include <QContactEmailAddress>

#include <QContactFamily>

#include <QContactGeoLocation>

#include <QContactGuid>

#include <QContactHobby>

#include <QContactName>

#include <QContactNickname>

#include <QContactNote>

#include <QContactOnlineAccount>

#include <QContactOrganization>

#include <QContactPhoneNumber>

#include <QContactRingtone>

#include <QContactTag>

#include <QContactUrl>

#include <QContactIdFilter>

#include <QContactExtendedDetail>

#include <QVersitContactExporter>

#include <QVersitContactImporter>

#include <QVersitReader>

#include <QVersitWriter>

#include <QHash>

#include <QString>

namespace {

QContactFetchHint basicFetchHint()

{

QContactFetchHint fetchHint;

fetchHint.setOptimizationHints(QContactFetchHint::NoRelationships |

QContactFetchHint::NoActionPreferences |

QContactFetchHint::NoBinaryBlobs);

return fetchHint;

}

QContactFilter localContactFilter()

{

// Contacts that are local to the device have sync target 'local' or 'was_local' or 'bluetooth'

QContactDetailFilter filterLocal, filterWasLocal, filterBluetooth;

filterLocal.setDetailType(QContactSyncTarget::Type, QContactSyncTarget::FieldSyncTarget);

filterWasLocal.setDetailType(QContactSyncTarget::Type, QContactSyncTarget::FieldSyncTarget);

filterLocal.setValue(QString::fromLatin1("local"));

filterWasLocal.setValue(QString::fromLatin1("was_local"));

}

bool nameIsEmpty(const QContactName &name)

{

if (name.isEmpty())

return true;

return (name.prefix().isEmpty() &&

name.firstName().isEmpty() &&

name.middleName().isEmpty() &&

name.lastName().isEmpty() &&

name.suffix().isEmpty());

}

QString contactNameString(const QContact &contact)

{

QStringList details;

QContactName name(contact.detail<QContactName>());

if (nameIsEmpty(name))

return QString();

details.append(name.prefix());

details.append(name.firstName());

details.append(name.middleName());

details.append(name.lastName());

details.append(name.suffix());

return details.join(QChar::fromLatin1('|'));

}

template<typename T, typename F>

QVariant detailValue(const T &detail, F field)

{

return detail.value(field);

}

typedef QMap<int, QVariant> DetailMap;

DetailMap detailValues(const QContactDetail &detail)

{

DetailMap rv(detail.values());

return rv;

}

static bool variantEqual(const QVariant &lhs, const QVariant &rhs)

{

// Work around incorrect result from QVariant::operator== when variants contain QList<int>

static const int QListIntType = QMetaType::type("QList<int>");

const int lhsType = lhs.userType();

if (lhsType != rhs.userType()) {

return false;

}

if (lhsType == QListIntType) {

return (lhs.value<QList<int> >() == rhs.value<QList<int> >());

}

return (lhs == rhs);

}

static bool detailValuesSuperset(const QContactDetail &lhs, const QContactDetail &rhs)

{

// True if all values in rhs are present in lhs

const DetailMap lhsValues(detailValues(lhs));

const DetailMap rhsValues(detailValues(rhs));

if (lhsValues.count() < rhsValues.count()) {

return false;

}

foreach (const DetailMap::key_type &key, rhsValues.keys()) {

if (!variantEqual(lhsValues[key], rhsValues[key])) {

return false;

}

}

return true;

}

static void fixupDetail(QContactDetail &)

{

}

// Fixup QContactUrl because importer produces incorrectly typed URL field

static void fixupDetail(QContactUrl &url)

{

QVariant urlField = url.value(QContactUrl::FieldUrl);

if (!urlField.isNull()) {

QString urlString = urlField.toString();

if (!urlString.isEmpty()) {

url.setValue(QContactUrl::FieldUrl, QUrl(urlString));

} else {

url.setValue(QContactUrl::FieldUrl, QVariant());

}

}

}

// Fixup QContactOrganization because importer produces invalid department

static void fixupDetail(QContactOrganization &org)

{

QVariant deptField = org.value(QContactOrganization::FieldDepartment);

if (!deptField.isNull()) {

QStringList deptList = deptField.toStringList();

// Remove any empty elements from the list

QStringList::iterator it = deptList.begin();

while (it != deptList.end()) {

if ((*it).isEmpty()) {

it = deptList.erase(it);

} else {

++it;

}

}

if (!deptList.isEmpty()) {

org.setValue(QContactOrganization::FieldDepartment, deptList);

} else {

org.setValue(QContactOrganization::FieldDepartment, QVariant());

}

}

}

template<typename T>

bool updateExistingDetails(QContact *updateContact, const QContact &importedContact, bool singular = false)

{

bool rv = false;

QList<T> existingDetails(updateContact->details<T>());

if (singular && !existingDetails.isEmpty())

return rv;

foreach (T detail, importedContact.details<T>()) {

// Make any corrections to the input

fixupDetail(detail);

// See if the contact already has a detail which is a superset of this one

bool found = false;

foreach (const T &existing, existingDetails) {

if (detailValuesSuperset(existing, detail)) {

found = true;

break;

}

}

if (!found) {

updateContact->saveDetail(&detail);

rv = true;

}

}

return rv;

}

bool mergeIntoExistingContact(QContact *updateContact, const QContact &importedContact)

{

bool rv = false;

// Update the existing contact with any details in the new import

rv |= updateExistingDetails<QContactAddress>(updateContact, importedContact);

rv |= updateExistingDetails<QContactAnniversary>(updateContact, importedContact);

rv |= updateExistingDetails<QContactAvatar>(updateContact, importedContact);

rv |= updateExistingDetails<QContactBirthday>(updateContact, importedContact, true);

rv |= updateExistingDetails<QContactEmailAddress>(updateContact, importedContact);

rv |= updateExistingDetails<QContactFamily>(updateContact, importedContact);

rv |= updateExistingDetails<QContactGeoLocation>(updateContact, importedContact);

rv |= updateExistingDetails<QContactGuid>(updateContact, importedContact);

rv |= updateExistingDetails<QContactHobby>(updateContact, importedContact);

rv |= updateExistingDetails<QContactNickname>(updateContact, importedContact);

rv |= updateExistingDetails<QContactNote>(updateContact, importedContact);

rv |= updateExistingDetails<QContactOnlineAccount>(updateContact, importedContact);

rv |= updateExistingDetails<QContactOrganization>(updateContact, importedContact);

rv |= updateExistingDetails<QContactPhoneNumber>(updateContact, importedContact);

rv |= updateExistingDetails<QContactRingtone>(updateContact, importedContact);

rv |= updateExistingDetails<QContactTag>(updateContact, importedContact);

rv |= updateExistingDetails<QContactUrl>(updateContact, importedContact);

rv |= updateExistingDetails<QContactExtendedDetail>(updateContact, importedContact);

return rv;

}

bool updateExistingContact(QContact *updateContact, const QContact &contact)

{

// Replace the imported contact with the existing version

QContact importedContact(*updateContact);

*updateContact = contact;

return mergeIntoExistingContact(updateContact, importedContact);

}

void setNickname(QContact &contact, const QString &text)

{

foreach (const QContactNickname &nick, contact.details<QContactNickname>()) {

if (nick.nickname() == text) {

return;

}

}

QContactNickname nick;

nick.setNickname(text);

contact.saveDetail(&nick);

}

}

QList<QContact> SeasideImport::buildImportContacts(const QList<QVersitDocument> &details, int *newCount, int *updatedCount)

{

if (newCount)

*newCount = 0;

if (updatedCount)

*updatedCount = 0;

// Read the contacts from the import details

importer.importDocuments(details);

QList<QContact> importedContacts(importer.contacts());

QHash<QString, int> importGuids;

QHash<QString, int> importNames;

QHash<QString, int> importLabels;

QSet<QContactDetail::DetailType> unimportableDetailTypes;

unimportableDetailTypes.insert(QContactDetail::TypeGlobalPresence);

unimportableDetailTypes.insert(QContactDetail::TypeVersion);

QList<QContact>::iterator it = importedContacts.begin();

while (it != importedContacts.end()) {

QContact &contact(*it);

// Remove any details that our backend can't store

foreach (QContactDetail detail, contact.details()) {

if (detail.type() == QContactSyncTarget::Type) {

// We allow some syncTarget values

const QString syncTarget(detail.value<QString>(QContactSyncTarget::FieldSyncTarget));

if (syncTarget == QStringLiteral("was_local") ||

syncTarget == QStringLiteral("bluetooth")) {

// These values are permissible

} else {

qDebug() << " Removing unimportable syncTarget:" << syncTarget;

contact.removeDetail(&detail);

}

} else if (unimportableDetailTypes.contains(detail.type())) {

qDebug() << " Removing unimportable detail:" << detail;

contact.removeDetail(&detail);

}

}

const QString guid = contact.detail<QContactGuid>().guid();

const QString name = contactNameString(contact);

const bool emptyName = name.isEmpty();

QString label;

if (emptyName) {

QContactName nameDetail = contact.detail<QContactName>();

contact.removeDetail(&nameDetail);

label = contact.detail<QContactDisplayLabel>().label();

if (label.isEmpty()) {

label = SeasideCache::generateDisplayLabelFromNonNameDetails(contact);

}

}

int previousIndex = -1;

QHash<QString, int>::const_iterator git = importGuids.find(guid);

if (!emptyName) {

// If we have a GUID match, but names differ, ignore the match

const QContact &previous(importedContacts[previousIndex]);

const QString previousName = contactNameString(previous);

if (!previousName.isEmpty() && (previousName != name)) {

previousIndex = -1;

// Remove the conflicting GUID from this contact

QContactGuid guidDetail = contact.detail<QContactGuid>();

contact.removeDetail(&guidDetail);

}

}

}

if (previousIndex == -1) {

if (!emptyName) {

QHash<QString, int>::const_iterator nit = importNames.find(name);

if (nit != importNames.end()) {

previousIndex = nit.value();

}

} else if (!label.isEmpty()) {

QHash<QString, int>::const_iterator lit = importLabels.find(label);

if (lit != importLabels.end()) {

previousIndex = lit.value();

}

}

}

QContact &previous(importedContacts[previousIndex]);

mergeIntoExistingContact(&previous, contact);

it = importedContacts.erase(it);

}

if (!emptyName) {

if (contact.details<QContactNickname>().isEmpty()) {

// Modify this contact to have the label as a nickname

setNickname(contact, label);

}

}

++it;

}

}

// Find all names and GUIDs for local contacts that might match these contacts

QContactFetchHint fetchHint(basicFetchHint());

fetchHint.setDetailTypesHint(QList<QContactDetail::DetailType>() << QContactName::Type << QContactNickname::Type << QContactGuid::Type);

QHash<QString, QContactId> existingGuids;

QHash<QString, QContactId> existingNames;

QHash<QString, QContactId> existingNicknames;

QContactManager *mgr(SeasideCache::manager());

foreach (const QContact &contact, mgr->contacts(localContactFilter(), QList<QContactSortOrder>(), fetchHint)) {

const QString guid = contact.detail<QContactGuid>().guid();

const QString name = contactNameString(contact);

if (!guid.isEmpty()) {

existingGuids.insert(guid, contact.id());

}

if (!name.isEmpty()) {

existingNames.insert(name, contact.id());

}

foreach (const QContactNickname &nick, contact.details<QContactNickname>()) {

existingNicknames.insert(nick.nickname(), contact.id());

}

}

// Find any imported contacts that match contacts we already have

it = importedContacts.begin();

while (it != importedContacts.end()) {

const QString name = contactNameString(*it);

const bool emptyName = name.isEmpty();

QContactId existingId;

QHash<QString, QContactId>::const_iterator git = existingGuids.find(guid);

if (git != existingGuids.end()) {

existingId = *git;

if (!emptyName) {

// If we have a GUID match, but names differ, ignore the match

QMap<QContactId, QString>::iterator nit = existingContactNames.find(existingId);

if (nit != existingContactNames.end()) {

const QString &existingName(*nit);

if (!existingName.isEmpty() && (existingName != name)) {

existingId = QContactId();

// Remove the conflicting GUID from this contact

QContactGuid guidDetail = (*it).detail<QContactGuid>();

(*it).removeDetail(&guidDetail);

}

}

}

}

if (existingId.isNull()) {

if (!emptyName) {

QHash<QString, QContactId>::const_iterator nit = existingNames.find(name);

if (nit != existingNames.end()) {

existingId = *nit;

}

} else {

foreach (const QContactNickname nick, (*it).details<QContactNickname>()) {

const QString nickname(nick.nickname());

if (!nickname.isEmpty()) {

QHash<QString, QContactId>::const_iterator nit = existingNicknames.find(nickname);

if (nit != existingNicknames.end()) {

existingId = *nit;

break;

}

}

}

}

}

existingIds.insert(existingId, (it - importedContacts.begin()));

++it;

} else {

// Combine these contacts with matching names

QContact &previous(importedContacts[*eit]);

mergeIntoExistingContact(&previous, *it);

} else {

++it;

}

}

int existingCount(existingIds.count());

if (existingCount > 0) {

// Retrieve all the contacts that we have matches for

QContactIdFilter idFilter;

idFilter.setIds(existingIds.keys());

QSet<QContactId> modifiedContacts;

QSet<QContactId> unmodifiedContacts;

foreach (const QContact &contact, mgr->contacts(idFilter & localContactFilter(), QList<QContactSortOrder>(), basicFetchHint())) {

if (it != existingIds.end()) {

// Update the existing version of the contact with any new details

bool modified = updateExistingContact(&importContact, contact);

if (modified) {

modifiedContacts.insert(importContact.id());

} else {

unmodifiedContacts.insert(importContact.id());

}

} else {

qWarning() << "unable to update existing contact:" << contact.id();

}

}

if (!unmodifiedContacts.isEmpty()) {

QList<QContact>::iterator it = importedContacts.begin();

while (it != importedContacts.end()) {

const QContact &importContact(*it);

const QContactId contactId(importContact.id());

if (unmodifiedContacts.contains(contactId) && !modifiedContacts.contains(contactId)) {

// This contact was not modified by import - don't update it

it = importedContacts.erase(it);

--existingCount;

} else {

++it;

}

}

}

}

if (updatedCount)

*updatedCount = existingCount;

if (newCount)

*newCount = importedContacts.count() - existingCount;

return importedContacts;

}