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

**

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

#include <qmessageaccountid.h>

#include <qmessagefolderid.h>

#include <qmessageid.h>

#include <qmessage_p.h>

#include <qmessagemanager.h>

#include <QDataStream>

#include <QFile>

#include <QVector>

#include <QDebug>

#include <mapix.h>

#include <Mapidefs.h>

#include <Mapitags.h>

#include <MAPIUtil.h>

#ifdef _WIN32_WCE

#include <cemapi.h>

#endif

#include <messagingutil_p.h>

// Missing definitions

#ifndef PR_PST_CONFIG_FLAGS

#define PR_PST_CONFIG_FLAGS PROP_TAG( PT_LONG, 0x6770 )

#endif

#ifndef PST_CONFIG_UNICODE

#define PST_CONFIG_UNICODE 0x80000000

#endif

#ifndef PR_PST_PATH_A

#define PR_PST_PATH_A PROP_TAG( PT_STRING8, 0x6700 )

#endif

namespace {

class Lptstr : public QVector<TCHAR>

{

public:

    Lptstr(int length) : QVector<TCHAR>(length){}

    operator TCHAR* (){ return QVector<TCHAR>::data(); }

};

Lptstr LptstrFromQString(const QString &src)

{

    uint length(src.length());

    Lptstr dst(length+1);

    const quint16 *data = src.utf16();

    const quint16 *it = data, *end = data + length;

    TCHAR *oit = dst;

    for ( ; it != end; ++it, ++oit) {

        *oit = static_cast<TCHAR>(*it);

    }

    *oit = TCHAR('\0');

    return dst;

}

QString QStringFromLptstr(LPCTSTR data)

{

    if (!data)

        return QString();

    return QString::fromUtf16(reinterpret_cast<const quint16*>(data));

}

class QueryAllRows

{

    static const int BatchSize = 20;

public:

    QueryAllRows(LPMAPITABLE ptable,

                 LPSPropTagArray ptaga,

                 LPSRestriction pres,

                 LPSSortOrderSet psos,

                 bool setPosition = true);

    ~QueryAllRows();

    bool query();

    LPSRowSet rows() const;

    QMessageManager::Error error() const;

private:

    LPMAPITABLE m_table;

    LPSPropTagArray m_tagArray;

    LPSRestriction m_restriction;

    LPSSortOrderSet m_sortOrderSet;

    LPSRowSet m_rows;

    QMessageManager::Error m_error;

};

QueryAllRows::QueryAllRows(LPMAPITABLE ptable,

                               LPSPropTagArray ptaga,

                               LPSRestriction pres,

                               LPSSortOrderSet psos,

                               bool setPosition)

    :

        m_table(ptable),

        m_tagArray(ptaga),

        m_restriction(pres),

        m_sortOrderSet(psos),

        m_rows(0),

        m_error(QMessageManager::NoError)

{

#ifndef _WIN32_WCE

    const ULONG options(TBL_BATCH);

#else

    const ULONG options(0);

#endif

    bool initFailed = false;

    initFailed |= FAILED(m_table->SetColumns(m_tagArray, options));

    if(m_restriction)

        initFailed |= FAILED(m_table->Restrict(m_restriction, options));

    if(m_sortOrderSet)

        initFailed |= FAILED(m_table->SortTable(m_sortOrderSet, options));

    if(setPosition)

        initFailed |= FAILED(m_table->SeekRow(BOOKMARK_BEGINNING, 0, NULL));

    if(initFailed) m_error = QMessageManager::ContentInaccessible;

}

QueryAllRows::~QueryAllRows()

{

    FreeProws(m_rows);

    m_rows = 0;

}

bool QueryAllRows::query()

{

    if(m_error != QMessageManager::NoError)

        return false;

    FreeProws(m_rows);

    m_rows = 0;

    m_error = QMessageManager::NoError;

    bool failed = FAILED(m_table->QueryRows( QueryAllRows::BatchSize, NULL, &m_rows));

    if(failed)

        m_error = QMessageManager::ContentInaccessible;

    if(failed || m_rows && !m_rows->cRows) return false;

    return true;

}

LPSRowSet QueryAllRows::rows() const

{

    return m_rows;

}

QMessageManager::Error QueryAllRows::error() const

{

    return m_error;

}

#ifndef _WIN32_WCE

GUID GuidPublicStrings = { 0x00020329, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 };

#else

GUID GuidPSMAPI = { 0x00020328, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 };

#endif

void doInit()

{

    static QMessageManager manager;

    Q_UNUSED(manager)

}

QByteArray binaryResult(const SPropValue &prop)

{

    return QByteArray(reinterpret_cast<const char*>(prop.Value.bin.lpb), prop.Value.bin.cb);

}

#ifndef _WIN32_WCE

IProfAdmin *openProfileAdmin()

{

    IProfAdmin *profAdmin(0);

    HRESULT rv = MAPIAdminProfiles(0, &profAdmin);

    if (HR_FAILED(rv)) {

        qWarning() << "openProfileAdmin: MAPIAdminProfiles failed";

    }

    return profAdmin;

}

IMsgServiceAdmin *openServiceAdmin(const QByteArray &profileName, IProfAdmin *profAdmin)

{

    IMsgServiceAdmin *svcAdmin(0);

    HRESULT rv = profAdmin->AdminServices(reinterpret_cast<LPTSTR>(const_cast<char*>(profileName.data())), 0, 0, 0, &svcAdmin);

    if (HR_FAILED(rv)) {

        qWarning() << "openServiceAdmin: AdminServices failed";

    }

    return svcAdmin;

}

typedef QPair<QByteArray, bool> ProfileDetail;

QList<ProfileDetail> profileDetails(LPPROFADMIN profAdmin)

{

    QList<ProfileDetail> result;

    LPMAPITABLE profileTable(0);

    HRESULT rv = profAdmin->GetProfileTable(0, &profileTable);

    if (HR_SUCCEEDED(rv)) {

        SizedSPropTagArray(2, cols) = {2, {PR_DISPLAY_NAME_A, PR_DEFAULT_PROFILE}};

        QueryAllRows qar(profileTable, reinterpret_cast<LPSPropTagArray>(&cols), NULL, NULL);

        while(qar.query()) {

            for (uint n = 0; n < qar.rows()->cRows; ++n) {

                if (qar.rows()->aRow[n].lpProps[0].ulPropTag == PR_DISPLAY_NAME_A) {

                    QByteArray profileName(qar.rows()->aRow[n].lpProps[0].Value.lpszA);

                    bool defaultProfile(qar.rows()->aRow[n].lpProps[1].Value.b);

                    result.append(qMakePair(profileName, defaultProfile));

                }

            }

        }

        if(qar.error() != QMessageManager::NoError)

            qWarning() << "profileNames: QueryAllRows failed";

        profileTable->Release();

    } else {

        qWarning() << "profileNames: GetProfileTable failed";

    }

    return result;

}

QByteArray findDefaultProfileName(IProfAdmin *profAdmin)

{

    QByteArray defaultProfileName;

    foreach (const ProfileDetail &profile, profileDetails(profAdmin)) {

        if (profile.second) {

            defaultProfileName = profile.first;

            break;

        }

    }

    if (defaultProfileName.isEmpty()) {

        qWarning() << "findDefaultProfileName: no default profile!";

    }

    return defaultProfileName;

}

typedef QPair<QPair<QByteArray, QByteArray>, MAPIUID> ServiceDetail;

QList<ServiceDetail> serviceDetails(LPSERVICEADMIN svcAdmin)

{

    QList<ServiceDetail> result;

    IMAPITable *svcTable(0);

    HRESULT rv = svcAdmin->GetMsgServiceTable(0, &svcTable);

    if (HR_SUCCEEDED(rv)) {

        SizedSPropTagArray(3, cols) = {3, {PR_SERVICE_NAME_A, PR_DISPLAY_NAME_A, PR_SERVICE_UID}};

        QueryAllRows qar(svcTable, reinterpret_cast<LPSPropTagArray>(&cols), 0, 0);

        while(qar.query()) {

            for (uint n = 0; n < qar.rows()->cRows; ++n) {

                if (qar.rows()->aRow[n].lpProps[0].ulPropTag == PR_SERVICE_NAME_A) {

                    QByteArray svcName(qar.rows()->aRow[n].lpProps[0].Value.lpszA);

                    QByteArray displayName;

                    if (qar.rows()->aRow[n].lpProps[1].ulPropTag == PR_DISPLAY_NAME_A) {

                        displayName = QByteArray(qar.rows()->aRow[n].lpProps[1].Value.lpszA);

                    }

                    MAPIUID svcUid(*(reinterpret_cast<MAPIUID*>(qar.rows()->aRow[n].lpProps[2].Value.bin.lpb)));

                    result.append(qMakePair(qMakePair(svcName, displayName), svcUid));

                }

            }

        }

        if(qar.error() != QMessageManager::NoError)

            qWarning() << "serviceDetails: QueryAllRows failed";

        svcTable->Release();

    } else {

        qWarning() << "serviceDetails: GetMsgServiceTable failed";

    }

    return result;

}

#endif

#ifndef _WIN32_WCE

typedef QPair<QByteArray, QPair<QByteArray, QByteArray> > StoreDetail;

#else

typedef QPair<QString, QByteArray> StoreDetail;

#endif

QList<StoreDetail> storeDetails(LPMAPISESSION session)

{

    QList<StoreDetail> result;

    IMAPITable *storesTable(0);

    HRESULT rv = session->GetMsgStoresTable(0, &storesTable);

    if (HR_SUCCEEDED(rv)) {

#ifndef _WIN32_WCE

        SizedSPropTagArray(3, cols) = {3, {PR_DISPLAY_NAME_A, PR_RECORD_KEY, PR_ENTRYID}};

#else

        SizedSPropTagArray(2, cols) = {2, {PR_DISPLAY_NAME, PR_ENTRYID}};

#endif

        QueryAllRows qar(storesTable, reinterpret_cast<LPSPropTagArray>(&cols), 0, 0, false);

        while(qar.query()) {

            for (uint n = 0; n < qar.rows()->cRows; ++n) {

                SPropValue *props(qar.rows()->aRow[n].lpProps);

                if (props[0].ulPropTag == cols.aulPropTag[0]) {

#ifndef _WIN32_WCE

                    QByteArray storeName(props[0].Value.lpszA);

                    QByteArray recordKey(binaryResult(props[1]));

                    QByteArray entryId(binaryResult(props[2]));

                    result.append(qMakePair(storeName, qMakePair(recordKey, entryId)));

#else

                    QString storeName(QStringFromLptstr(props[0].Value.lpszW));

                    QByteArray entryId(binaryResult(props[1]));

                    result.append(qMakePair(storeName, entryId));

#endif

                }

            }

        }

        if(qar.error() != QMessageManager::NoError)

            qWarning() << "storeDetails: QueryAllRows failed";

        storesTable->Release();

    } else {

        qWarning() << "storeDetails: GetMsgStoresTable failed";

    }

    return result;

}

QMessageAccountId accountIdFromRecordKey(const QByteArray &recordKey)

{

    QByteArray encodedId;

    {

        QDataStream encodedIdStream(&encodedId, QIODevice::WriteOnly);

        encodedIdStream << recordKey;

    }

    return QMessageAccountId(MessagingUtil::addIdPrefix(encodedId.toBase64()));

}

QMessageFolderId folderIdFromProperties(const QByteArray &recordKey, const QByteArray &entryId, const QByteArray &storeKey)

{

    QByteArray encodedId;

    {

        QDataStream encodedIdStream(&encodedId, QIODevice::WriteOnly);

#ifndef _WIN32_WCE

        encodedIdStream << recordKey << storeKey;

        if (!entryId.isEmpty()) {

            encodedIdStream << entryId;

        }

#else

        encodedIdStream << entryId << storeKey;

        if (!recordKey.isEmpty()) {

            encodedIdStream << recordKey;

        }

#endif

    }

    return QMessageFolderId(MessagingUtil::addIdPrefix(encodedId.toBase64()));

}

QByteArray objectProperty(IMAPIProp *object, ULONG tag)

{

    QByteArray result;

    if (object) {

        SPropValue *prop(0);

        HRESULT rv = HrGetOneProp(object, tag, &prop);

        if (HR_SUCCEEDED(rv)) {

            result = binaryResult(*prop);

            MAPIFreeBuffer(prop);

        } else {

            qWarning() << "objectProperty: HrGetOneProp failed";

        }

    }

    return result;

}

QString stringProperty(IMAPIProp *object, ULONG tag)

{

    QString result;

    if (object) {

        SPropValue *prop(0);

        HRESULT rv = HrGetOneProp(object, tag, &prop);

        if (HR_SUCCEEDED(rv)) {

            result = QString::fromUtf16(reinterpret_cast<quint16*>(prop->Value.LPSZ));

            MAPIFreeBuffer(prop);

        } else if (rv != MAPI_E_NOT_FOUND) {

            qWarning() << "stringProperty: HrGetOneProp failed";

        }

    }

    return result;

}

ULONG createNamedProperty(IMAPIProp *object, const QString &name)

{

    ULONG result = 0;

    if (!name.isEmpty()) {

        Lptstr nameBuffer = LptstrFromQString(name);

        MAPINAMEID propName = { 0 };

#ifndef _WIN32_WCE

        propName.lpguid = &GuidPublicStrings;

#else

        propName.lpguid = &GuidPSMAPI;

#endif

        propName.ulKind = MNID_STRING;

        propName.Kind.lpwstrName = nameBuffer;

        LPMAPINAMEID propNames = &propName;

        SPropTagArray *props;

        HRESULT rv = object->GetIDsFromNames(1, &propNames, MAPI_CREATE, &props);

        if (HR_SUCCEEDED(rv)) {

            result = props->aulPropTag[0] | PT_UNICODE;

            MAPIFreeBuffer(props);

        } else {

            qWarning() << "createNamedProperty: GetIDsFromNames failed";

        }

    }

    return result;

}

ULONG getNamedPropertyTag(IMAPIProp *object, const QString &name)

{

    ULONG result = 0;

    if (!name.isEmpty()) {

        Lptstr nameBuffer = LptstrFromQString(name);

        MAPINAMEID propName = { 0 };

#ifndef _WIN32_WCE

        propName.lpguid = &GuidPublicStrings;

#else

        propName.lpguid = &GuidPSMAPI;

#endif

        propName.ulKind = MNID_STRING;

        propName.Kind.lpwstrName = nameBuffer;

        LPMAPINAMEID propNames = &propName;

        SPropTagArray *props;

        HRESULT rv = object->GetIDsFromNames(1, &propNames, 0, &props);

        if (HR_SUCCEEDED(rv)) {

            if (props->aulPropTag[0] != PT_ERROR) {

                result = props->aulPropTag[0] | PT_UNICODE;

            }

            MAPIFreeBuffer(props);

        } else {

            qWarning() << "getNamedPropertyTag: GetIDsFromNames failed";

        }

    }

    return result;

}

bool setNamedProperty(IMAPIProp *object, ULONG tag, const QString &value)

{

    if (object && tag && !value.isEmpty()) {

        SPropValue prop = { 0 };

        prop.ulPropTag = tag;

        prop.Value.LPSZ = reinterpret_cast<LPTSTR>(const_cast<quint16*>(value.utf16()));

        HRESULT rv = object->SetProps(1, &prop, 0);

        if (HR_SUCCEEDED(rv)) {

            return true;

        } else {