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

**

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

#include <QByteArray>

#include <QBuffer>

#include <QUrl>

#include <QPixmap>

#include "qcontactmanager.h"

#include "qtcontacts.h"

#include "qcontactwincebackend_p.h"

QTM_USE_NAMESPACE

/*!

 * Convert from the supplied CEPROPVAL \a val into a QVariant.

 */

static QVariant CEPropValToQVariant(const CEPROPVAL& val)

{

    if (val.propid != PIMPR_INVALID_ID) {

        switch(TypeFromPropID(val.propid)) {

            case CEVT_BOOL:

                return QVariant(val.val.boolVal);

            case CEVT_I2:

                return QVariant(val.val.iVal);

            case CEVT_UI2:

                return QVariant(val.val.uiVal);

            case CEVT_I4:

                return QVariant(val.val.lVal);

            case CEVT_UI4:

            case CEVT_PIM_AUTO_I4:

                return QVariant((quint32)val.val.ulVal);

            case CEVT_R8:

                return QVariant(val.val.dblVal);

            case CEVT_FILETIME:

            {

                // Convert FILETIME to QDateTime

                if (val.val.filetime.dwHighDateTime != 0 || val.val.filetime.dwLowDateTime != 0) {

                    SYSTEMTIME st;

                    if(FileTimeToSystemTime(&val.val.filetime, &st))

                        return QVariant(QDateTime(QDate(st.wYear, st.wMonth, st.wDay), QTime(st.wHour, st.wMinute, st.wSecond, st.wMilliseconds)));

                }

                break; // Fall through to return at bottom

            }

            case CEVT_LPWSTR:

                return QVariant(QString::fromWCharArray(val.val.lpwstr));

            case CEVT_BLOB: // Not used yet

            case CEVT_PIM_STREAM: // Not used yet

                break;

        }

    }

    return QVariant();

}

class WcsdupHelper {

public:

    WcsdupHelper() {}

    ~WcsdupHelper() {

        clear();

    }

    LPWSTR dup(const ushort* str) {

        LPWSTR newStr = wcsdup(str);

        m_list.push_back(newStr);

        return newStr;

    }

    void clear() {

        foreach (const LPWSTR& str, m_list) {

            free(str);

        }

        m_list.clear();

    }

private:

    QList<LPWSTR> m_list; 

};

static WcsdupHelper wcsdupHelper;

/*!

 * Convert the supplied QString \a value into a CEPROPVAL with the supplied \a id.

 *

 * The caller is responsible for freeing the LPWSTR within the CEPROPVAL.

 *

 * The datatype of the \a id is not checked.

 */

static CEPROPVAL convertToCEPropVal(const CEPROPID& id, const QString& value)

{

    CEPROPVAL val;

    val.propid = id;

    val.wFlags = 0;

    val.wLenData = 0;

    if (!value.isEmpty()) {

        val.val.lpwstr = wcsdupHelper.dup(value.utf16());

    } else {

        val.val.lpwstr = 0;

    }

    return val;

}

/*!

 * Convert the supplied QDateTime \a value into a CEPROPVAL with the supplied \a id.

 *

 * The datatype of the \a id is not checked.

 */

static CEPROPVAL convertToCEPropVal(const CEPROPID& id, const QDateTime& value)

{

    CEPROPVAL val;

    val.propid = id;

    val.wFlags = 0;

    val.wLenData = 0;

    SYSTEMTIME st;

    st.wDay = value.date().day();

    st.wMonth = value.date().month();

    st.wYear = value.date().year();

    st.wHour = value.time().hour();

    st.wMinute = value.time().minute();

    st.wSecond = value.time().second();

    st.wMilliseconds = value.time().msec();

    SystemTimeToFileTime(&st, &val.val.filetime); // XXX check for error?

    return val;

}

// Structures for mapping stuffs

// Our fields to POOM

// QMap<definition, {QMap<field, poomid>, datatype, maxnumber}>

typedef bool (*processContactPoomElement)(const QContactWinCEEngine* e, IItem* contact, const QContactDetail& detail, QVector<CEPROPVAL>& props);

// POOM to us

// something like

// {PIMPR_,PIMPR_} -> function

// Might then need PIMPR -> bag above

struct PoomContactElement;

typedef void (*processPoomContactElement)(const QContactWinCEEngine* e, IItem* contact, const QVariantList& values, QContact& ret);

struct PoomContactElement {

    QList<CEPROPID> poom;

    processPoomContactElement func;

};

static void setIfNotEmpty(QContactDetail& detail, const QString& field, const QString& value)

{

    if (!value.isEmpty())

        detail.setValue(field, value);

}

static void processName(const QContactWinCEEngine* /*engine*/, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    QContactName name;

    setIfNotEmpty(name, QContactName::FieldPrefix, values[0].toString());

    setIfNotEmpty(name, QContactName::FieldFirstName, values[1].toString());

    setIfNotEmpty(name, QContactName::FieldMiddleName, values[2].toString());

    setIfNotEmpty(name, QContactName::FieldLastName, values[3].toString());

    setIfNotEmpty(name, QContactName::FieldSuffix, values[4].toString());

    setIfNotEmpty(name, QContactName::FieldCustomLabel, values[5].toString());

    if (!name.isEmpty())

        ret.saveDetail(&name);

}

static bool GetStreamSize(IStream* pStream, ULONG* pulSize)

{

    HRESULT hr;

    LARGE_INTEGER  li = {0};

    ULARGE_INTEGER uliZero = {0};

    ULARGE_INTEGER uli;

    if (pStream != NULL && pulSize != NULL) {

        hr = pStream->Seek(li, STREAM_SEEK_END, &uli);

        if (SUCCEEDED(hr)) {

            *pulSize = uli.LowPart;

            hr = pStream->Seek(li, STREAM_SEEK_SET, &uliZero);

            return SUCCEEDED(hr);

        }

    }

    return false;

}

static bool loadThumbnailData(IItem* contact, QByteArray* data)

{

    HRESULT   hr;

    SimpleComPointer<IStream>  pStream = NULL;

    ULONG     ulSize;

    // Extract the picture from the contact

    hr = contact->OpenProperty(PIMPR_PICTURE, GENERIC_READ, &pStream);

    if (FAILED(hr))

        return false;

    hr = GetStreamSize(pStream, &ulSize);

    if (FAILED(hr))

        return false;

    // In some cases, the property may exist even if there is no picture.

    // Make sure we can access the stream and don't have a 0 byte stream

    if (ulSize > 0 && pStream != NULL) {

        ULONG     ulSize, readSize;

        if (!GetStreamSize(pStream, &ulSize))

            return false;

        // Prepares the data buffer

        data->resize(ulSize);

        // Read all into the data buffer until reach the end of stream

        readSize = 0;

        char* p = data->data();

        while(ulSize && SUCCEEDED(hr)) {

            p += readSize;

            hr = pStream->Read(p, ulSize, &readSize);

            ulSize -= readSize;

        }

        if (FAILED(hr))

            return false;

    }

    return true;

}

static bool saveThumbnailData(IItem* contact, const QByteArray& data)

{

    HRESULT   hr;

    SimpleComPointer<IStream>  pStream = NULL;

    hr = contact->OpenProperty(PIMPR_PICTURE, GENERIC_WRITE, &pStream);

    if (FAILED(hr))

        return false;

    ULONG     ulWrittenSize;

    pStream->Write(data.data(), data.size(), &ulWrittenSize);

    if (FAILED(hr))

        return false;

    hr = pStream->Commit(0);

    if (FAILED(hr))

        return false;

    hr = contact->Save();

    if (FAILED(hr))

        return false;

    return true;

}

static void processAvatar(const QContactWinCEEngine* engine, IItem* contact, const QVariantList& values, QContact& ret)

{

    Q_UNUSED(engine);

    Q_UNUSED(contact);

    QContactAvatar avatar;

    QString imageUrl = values[0].toString();

    QString videoUrl = values[1].toString();

    setIfNotEmpty(avatar, QContactAvatar::FieldImageUrl, values[0].toString());

    setIfNotEmpty(avatar, QContactAvatar::FieldVideoUrl, values[1].toString());

    if (!avatar.isEmpty())

        ret.saveDetail(&avatar);

}

static void processThumbnail(IItem* contact, QContact& ret)

{

    QContactThumbnail thumbnail;

    QByteArray data;

    if (loadThumbnailData(contact, &data)) {

        if (!data.isEmpty()) {

            QImage image;

            image.loadFromData(data, "PNG");

            thumbnail.setThumbnail(image);

        }

    }

    if (!thumbnail.isEmpty())

        ret.saveDetail(&thumbnail);

}

static void processAddress(const QContactWinCEEngine*, const QString& context, const QVariantList& values, QContact& ret)

{

    QContactAddress address;

    address.setContexts(context);

    setIfNotEmpty(address, QContactAddress::FieldStreet, values[0].toString());

    setIfNotEmpty(address, QContactAddress::FieldPostcode, values[1].toString());

    setIfNotEmpty(address, QContactAddress::FieldLocality, values[2].toString());

    setIfNotEmpty(address, QContactAddress::FieldRegion, values[3].toString());

    setIfNotEmpty(address, QContactAddress::FieldCountry, values[4].toString());

    if (!address.isEmpty())

        ret.saveDetail(&address);

}

static void processHomeAddress(const QContactWinCEEngine* e, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    processAddress(e, QContactDetail::ContextHome, values, ret);

}

static void processWorkAddress(const QContactWinCEEngine* e, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    processAddress(e, QContactDetail::ContextWork, values, ret);

}

static void processOtherAddress(const QContactWinCEEngine* e, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    processAddress(e, QContactDetail::ContextOther, values, ret);

}

static void processEmails(const QContactWinCEEngine*, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    // First value is our additional metadata..

    // takes the form of a single character for each email address for the context

    // Since email addresses don't bubble up if you remove one, we don't store the

    // full value. but we could..

    QString meta = values[0].toString();

    // Just create an email address for each value (we're expecting 3)

    for (int j=1; j < values.size(); j++) {

        QVariant v = values.at(j);

        if (!v.isNull()) {

            QContactEmailAddress e;

            e.setValue(QContactEmailAddress::FieldEmailAddress, v);

            QChar m = meta.at(j - 1);

            if (m == 'H')

                e.setContexts(QContactDetail::ContextHome);

            else if (m == 'W')

                e.setContexts(QContactDetail::ContextWork);

            ret.saveDetail(&e);

        }

    }

}

static void processPhones(const QContactWinCEEngine*, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    // Just like emails, the first value is our additional metadata

    // metadata for phone numbers is somewhat crazy.

    // We use the following characters:

    //

    // space = default for type

    // H = Home context, no type modifier

    // W = Work context, no type modifier

    // O = Other context

    // N = No context

    // In general, they should only apply to PROPIDs that don't fully specify both

    // (e.g. home_fax is fully specified, mobile is not), but we occasionally run out

    // of places for anonymous numbers and stick them in different places.

    // Indexing is the same as the input list

    QString meta = values[0].toString();

    for (int i=0; i < values.count() - 1; i++) {

        const QVariant& v = values.at(i + 1);

        if (!v.isNull()) {

            QContactPhoneNumber number;

            number.setValue(QContactPhoneNumber::FieldNumber, v);

            QChar m = 0;

            switch(i) {

                case 0: // Business phone

                case 1:

                    m = meta.at(i);

                    if (m ==  ' ')

                        m = 'W';

                    number.setSubTypes(QContactPhoneNumber::SubTypeVoice);

                    break;

                case 2: // Car

                    m = meta.at(i);

                    number.setSubTypes(QContactPhoneNumber::SubTypeCar);

                    break;

                case 3: // Mobile

                    m = meta.at(i);

                    number.setSubTypes(QContactPhoneNumber::SubTypeMobile);

                    break;

                case 4: // Home phones

                case 5:

                    m = meta.at(i);

                    if (m ==  ' ')

                        m = 'H';

                    number.setSubTypes(QContactPhoneNumber::SubTypeVoice);

                    break;

                case 6: // Pager

                    m = meta.at(i);

                    number.setSubTypes(QContactPhoneNumber::SubTypePager);

                    break;

                case 7: // Radio telephone (??)

                    m = meta.at(i);

                    number.setSubTypes(QContactPhoneNumber::SubTypeMobile);

                    break;

                case 8: // SIM entry

                    break;

                case 9: // Home fax

                    m = meta.at(i);

                    if (m ==  ' ')

                        m = 'H';

                    number.setSubTypes(QContactPhoneNumber::SubTypeFax);

                    break;

                case 10: // Business fax

                    m = meta.at(i);

                    if (m ==  ' ')

                        m = 'W';

                    number.setSubTypes(QContactPhoneNumber::SubTypeFax);

                    break;

            }

            if (m == 'H')

                number.setContexts(QContactDetail::ContextHome);

            else if (m == 'W')

                number.setContexts(QContactDetail::ContextWork);

            else if (m == 'O')

                number.setContexts(QContactDetail::ContextOther);

            ret.saveDetail(&number);

        }

    }

}

static void processDates(const QContactWinCEEngine*, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    // We get anniversary, then birthday

    if (!values[0].toDate().isNull()) {

        QContactAnniversary ann;

        ann.setOriginalDate(values[0].toDate());

        ret.saveDetail(&ann);

    }

    if (!values[1].toDate().isNull()) {

        QContactBirthday bday;

        bday.setDate(values[1].toDate());

        ret.saveDetail(&bday);

    }

}

static void processId(const QContactWinCEEngine* e, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    QContactId id;

    id.setLocalId(values.at(0).toUInt());

    id.setManagerUri(e->managerUri());

    ret.setId(id);

}

static void processNickname(const QContactWinCEEngine*, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    QContactNickname nick;

    setIfNotEmpty(nick, QContactNickname::FieldNickname, values[0].toString());

    if (!nick.isEmpty())

        ret.saveDetail(&nick);

}

static void processWebpage(const QContactWinCEEngine*, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    QContactUrl url;

    setIfNotEmpty(url, QContactUrl::FieldUrl, values[0].toString());

    if (!url.isEmpty())

        ret.saveDetail(&url);

}

static void processOrganisation(const QContactWinCEEngine*, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    QContactOrganization org;

    setIfNotEmpty(org, QContactOrganization::FieldName, values[0].toString());

    setIfNotEmpty(org, QContactOrganization::FieldDepartment, values[1].toString());

    setIfNotEmpty(org, QContactOrganization::FieldLocation, values[2].toString());

    setIfNotEmpty(org, QContactOrganization::FieldTitle, values[3].toString());

    setIfNotEmpty(org, QContactOrganization::FieldAssistantName, values[4].toString());

    if (!org.isEmpty())

        ret.saveDetail(&org);

}

static void processFamily(const QContactWinCEEngine*, IItem* /*contact*/, const QVariantList& values, QContact& ret)

{

    QContactFamily family;

    setIfNotEmpty(family, QContactFamily::FieldSpouse, values[0].toString());

    setIfNotEmpty(family, QContactFamily::FieldChildren, values[1].toString());

    if (!family.isEmpty())

        ret.saveDetail(&family);

}