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

**

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

**

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

#ifndef _UNICODE

#define _UNICODE

#endif

#ifndef MDB_ONLINE

#define MDB_ONLINE ((ULONG) 0x00000100)

#endif

#ifndef DELETE_HARD_DELETE

#define DELETE_HARD_DELETE ((ULONG) 0x00000010)

#endif

#ifndef STORE_HTML_OK

#define STORE_HTML_OK ((ULONG)0x00010000)

#endif

#ifndef PR_IS_NEWSGROUP

#define PR_IS_NEWSGROUP PROP_TAG( PT_BOOLEAN, 0x6697 )

#endif

#ifndef PR_IS_NEWSGROUP_ANCHOR

#define PR_IS_NEWSGROUP_ANCHOR PROP_TAG( PT_BOOLEAN, 0x6696 )

#endif

#ifndef PR_EXTENDED_FOLDER_FLAGS

#define PR_EXTENDED_FOLDER_FLAGS PROP_TAG( PT_BINARY, 0x36DA )

#endif

#include "winhelpers_p.h"

#include "qmessageid_p.h"

#include "qmessagefolderid_p.h"

#include "qmessageaccountid_p.h"

#include "qmessage_p.h"

#include "qmessagecontentcontainer_p.h"

#include "qmessagefilter_p.h"

#include "qmessagesortorder_p.h"

#include "qmessagefolder_p.h"

#include "qmessagefolderfilter_p.h"

#include "qmessagefoldersortorder_p.h"

#include "qmessageaccount_p.h"

#include "qmessageaccountfilter_p.h"

#include "qmessageaccountsortorder_p.h"

#include "qmessagestore_p.h"

#include "messagingutil_p.h"

#include <QCoreApplication>

#include <QDebug>

#include <QFile>

#include <QTextCodec>

#include <QThreadStorage>

#include <QTimer>

#include <QMutexLocker>

#include <shlwapi.h>

#include <shlguid.h>

#include <tchar.h>

#ifdef _WIN32_WCE

#include "win32wce/qmailmessage.h"

#include <cemapi.h>

#endif

//unexported before Windows 7, include manually

#ifndef IID_PPV_ARGS

extern "C++"

{

    template<typename T> void** IID_PPV_ARGS_Helper(T** pp)

    {

        // make sure everyone derives from IUnknown

        static_cast<IUnknown*>(*pp);

        return reinterpret_cast<void**>(pp);

    }

}

#define IID_PPV_ARGS(ppType) __uuidof(**(ppType)), IID_PPV_ARGS_Helper(ppType)

#endif //IID_PPV_ARGSA

QTM_BEGIN_NAMESPACE

namespace WinHelpers

{

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

    {

        SPropValue prop = { 0 };

        prop.ulPropTag = tag;

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

        return HR_SUCCEEDED(HrSetOneProp(object, &prop));

    }

    bool setMapiProperty(IMAPIProp *object, ULONG tag, LONG value)

    {

        SPropValue prop = { 0 };

        prop.ulPropTag = tag;

        prop.Value.l = value;

        return HR_SUCCEEDED(HrSetOneProp(object, &prop));

    }

    bool setMapiProperty(IMAPIProp *object, ULONG tag, ULONG value)

    {

        SPropValue prop = { 0 };

        prop.ulPropTag = tag;

        prop.Value.ul = value;

        return HR_SUCCEEDED(HrSetOneProp(object, &prop));

    }

    bool setMapiProperty(IMAPIProp *object, ULONG tag, bool value)

    {

        SPropValue prop = { 0 };

        prop.ulPropTag = tag;

        prop.Value.b = value;

        return HR_SUCCEEDED(HrSetOneProp(object, &prop));

    }

    bool setMapiProperty(IMAPIProp *object, ULONG tag, FILETIME value)

    {

        SPropValue prop = { 0 };

        prop.ulPropTag = tag;

        prop.Value.ft = value;

        return HR_SUCCEEDED(HrSetOneProp(object, &prop));

    }

    bool setMapiProperty(IMAPIProp *object, ULONG tag, MapiEntryId value)

    {

        SBinary s;

        s.cb = value.count();

        s.lpb = reinterpret_cast<LPBYTE>(value.data());

        SPropValue prop = { 0 };

        prop.ulPropTag = tag;

        prop.Value.bin = s;

        return HR_SUCCEEDED(HrSetOneProp(object, &prop));

    }

    bool getMapiProperty(IMAPIProp *object, ULONG tag, ULONG *value)

    {

        bool result(false);

        SPropValue *prop;

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

        if (HR_SUCCEEDED(rv)) {

            if (prop->ulPropTag == tag) {

                *value = prop->Value.ul;

                result = true;

            }

            MAPIFreeBuffer(prop);

        }

        return result;

    }

    bool getMapiProperty(IMAPIProp *object, ULONG tag, LONG *value)

    {

        bool result(false);

        SPropValue *prop;

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

        if (HR_SUCCEEDED(rv)) {

            if (prop->ulPropTag == tag) {

                *value = prop->Value.l;

                result = true;

            }

            MAPIFreeBuffer(prop);

        }

        return result;

    }

    bool getMapiProperty(IMAPIProp *object, ULONG tag, QByteArray *value)

    {

        bool result(false);

        SPropValue *prop;

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

        if (HR_SUCCEEDED(rv)) {

            if (prop->ulPropTag == tag) {

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

                result = true;

            }

            MAPIFreeBuffer(prop);

        }

        return result;

    }

    bool getMapiProperty(IMAPIProp *object, ULONG tag, QString *value)

    {

        bool result(false);

        SPropValue *prop;

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

        if (HR_SUCCEEDED(rv)) {

            if (prop->ulPropTag == tag) {

                *value = QStringFromLpctstr(prop->Value.lpszW);

                result = true;

            }

            MAPIFreeBuffer(prop);

        }

        return result;

    }

}

using namespace WinHelpers;

namespace {

    typedef QWeakPointer<WinHelpers::MapiInitializer> InitRecord;

    typedef InitRecord *InitRecordPtr;

    QThreadStorage<InitRecordPtr> initializer;

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

    FILETIME toFileTime(const QDateTime &dt)

    {

        FILETIME ft = {0};

        QDate date(dt.date());

        QTime time(dt.time());

        SYSTEMTIME st = {0};

        st.wYear = date.year();

        st.wMonth = date.month();

        st.wDay = date.day();

        st.wHour = time.hour();

        st.wMinute = time.minute();

        st.wSecond = time.second();

        st.wMilliseconds = time.msec();

        SystemTimeToFileTime(&st, &ft);

        return ft;

    }

    QDateTime fromFileTime(const FILETIME &ft)

    {

        SYSTEMTIME st = {0};

        FileTimeToSystemTime(&ft, &st);

        QString dateStr(QString("yyyy%1M%2d%3h%4m%5s%6z%7").arg(st.wYear).arg(st.wMonth).arg(st.wDay).arg(st.wHour).arg(st.wMinute).arg(st.wSecond).arg(st.wMilliseconds));

        QDateTime dt(QDateTime::fromString(dateStr, "'yyyy'yyyy'M'M'd'd'h'h'm'm's's'z'z"));

        dt.setTimeSpec(Qt::UTC);

        return dt;

    }

    struct AccountFilterPredicate

    {

        const QMessageAccountFilter &_filter;

        AccountFilterPredicate(const QMessageAccountFilter &filter) : _filter(filter) {}

        bool operator()(const MapiStorePtr &store) const

        {

            return QMessageAccountFilterPrivate::matchesStore(_filter, store);

        }

    };

    //used in preference to HrQueryAllRows

    //as per: http://blogs.msdn.com/stephen_griffin/archive/2009/03/23/try-not-to-query-all-rows.aspx

    class QueryAllRows

    {

        static const int BatchSize = 20;

        public:

        QueryAllRows(LPMAPITABLE ptable,

                LPSPropTagArray ptaga,

                LPSRestriction pres,

                LPSSortOrderSet psos,

                bool setPosition = true);

        ~QueryAllRows();

        LONG rowCount();

        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)

    {

        bool initFailed = false;

#ifndef _WIN32_WCE

        unsigned long flags = TBL_BATCH;

#else

        unsigned long flags = 0;

#endif

        if(m_tagArray)

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

        if(m_restriction)

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

        if(m_sortOrderSet)

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

        if(setPosition) {

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

                qWarning() << "SeekRow function failed. Ensure it's not being called on hierarchy tables or message stores tables";

        }

        if(initFailed)

            m_error = QMessageManager::ContentInaccessible;

    }

    QueryAllRows::~QueryAllRows()

    {

        FreeProws(m_rows);

        m_rows = 0;

    }

    LONG QueryAllRows::rowCount()

    {

        if (m_error != QMessageManager::NoError)

            return -1;

        ULONG count(0);

        HRESULT rv = m_table->GetRowCount(0, &count);

        if (HR_FAILED(rv)) {

            m_error = QMessageManager::ContentInaccessible;

            return -1;

        }

        return count;

    }

    bool QueryAllRows::query()

    {

        if (m_error != QMessageManager::NoError)

            return false;

        FreeProws(m_rows);

        m_rows = 0;

        m_error = QMessageManager::NoError;

        HRESULT rv = m_table->QueryRows( QueryAllRows::BatchSize, NULL, &m_rows);

        if (HR_FAILED(rv)) {

            m_error = QMessageManager::ContentInaccessible;

            return false;

        }

        return (m_rows && m_rows->cRows);

    }

    LPSRowSet QueryAllRows::rows() const

    {

        return m_rows;

    }

    QMessageManager::Error QueryAllRows::error() const

    {

        return m_error;

    }

    ADRLIST *createAddressList(int count, int propertyCount)

    {

        ADRLIST *list(0);

        uint size = CbNewADRLIST(count);

        MAPIAllocateBuffer(size, reinterpret_cast<LPVOID*>(&list));

        if (list) {

            memset(list, 0, size);

            list->cEntries = count;

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

                list->aEntries[i].cValues = propertyCount;

                MAPIAllocateBuffer(propertyCount * sizeof(SPropValue), reinterpret_cast<LPVOID*>(&list->aEntries[i].rgPropVals));

            }

        }

        return list;

    }

    void fillAddressEntry(ADRENTRY &entry, const QMessageAddress &addr, LONG type, QList<LPTSTR> &addresses)

    {

        entry.rgPropVals[0].ulPropTag = PR_RECIPIENT_TYPE;

        entry.rgPropVals[0].Value.l = type;

#ifdef _WIN32_WCE

        QString addressStr = addr.addressee();

#else

        QString addressStr("[%1:%2]");

        addressStr = addressStr.arg(addr.type() == QMessageAddress::Phone ? "SMS" : "SMTP");

        addressStr = addressStr.arg(addr.addressee());

#endif

        // TODO: Escape illegal characters, as per: http://msdn.microsoft.com/en-us/library/cc842281.aspx

        uint len = addressStr.length();

        LPTSTR address = new TCHAR[len + 1];

        memcpy(address, addressStr.utf16(), len * sizeof(TCHAR));

        address[len] = 0;

#ifdef _WIN32_WCE

        entry.rgPropVals[1].ulPropTag = PR_EMAIL_ADDRESS;

        entry.rgPropVals[1].Value.LPSZ = address;

        if(addr.type() == QMessageAddress::Email)

        {

            //Set the address type(SMTP is the only type currently supported)

            entry.rgPropVals[2].ulPropTag = PR_ADDRTYPE;

            entry.rgPropVals[2].Value.LPSZ = L"SMTP";

        }

        else if(addr.type() == QMessageAddress::Phone)

        {

            //Set the address type(SMTP is the only type currently supported)

            entry.rgPropVals[2].ulPropTag = PR_ADDRTYPE;

            entry.rgPropVals[2].Value.LPSZ = L"SMS";

        }

        else

            qWarning() << "Unrecognized address type";

#else

        entry.rgPropVals[1].ulPropTag = PR_DISPLAY_NAME;

        entry.rgPropVals[1].Value.LPSZ = address;

#endif

        addresses.append(address);

    }

    bool resolveAddressList(ADRLIST *list, IMAPISession *session)

    {

        bool result(false);

        if (session) {

            IAddrBook *book(0);

            HRESULT rv = session->OpenAddressBook(0, 0, AB_NO_DIALOG, &book);

            if (HR_SUCCEEDED(rv)) {

                rv = book->ResolveName(0, MAPI_UNICODE, 0, list);

                if (HR_SUCCEEDED(rv)) {

                    result = true;

                } else {

                    qWarning() << "Unable to resolve addresses.";

                }

                book->Release();

            } else {

                qWarning() << "Unable to open address book.";

            }

        }

        return result;

    }

    void destroyAddressList(ADRLIST *list, QList<LPTSTR> &addresses)

    {

        foreach (LPTSTR address, addresses) {

            delete [] address;

        }

        addresses.clear();

        for (uint i = 0; i < list->cEntries; ++i) {

            MAPIFreeBuffer(list->aEntries[i].rgPropVals);

        }

        MAPIFreeBuffer(list);

    }

    ULONG addAttachment(IMessage* message, const QMessageContentContainer& attachmentContainer)

    {

        IAttach *attachment(0);

        ULONG attachmentNumber(0);