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

**

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

#include "qmessagefilter_p.h"

#include "qvariant.h"

#include "qdebug.h"

#include "winhelpers_p.h"

#include "qmessageaccountid_p.h"

#include "qmessagefolderid_p.h"

#include "qmessageid_p.h"

#include "addresshelper_p.h"

// Not sure if this will work on WinCE

#ifndef PR_SMTP_ADDRESS

#define PR_SMTP_ADDRESS 0x39FE001E

#endif

QTM_BEGIN_NAMESPACE

void QDateTimeToFileTime(const QDateTime &dt, FILETIME *ft)

{

    SYSTEMTIME st;

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

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

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

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

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

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

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

    SystemTimeToFileTime(&st, ft);

}

void QStringToWCharArray(const QString &str, wchar_t **buffer)

{

    delete *buffer;

    *buffer = new wchar_t[str.length() +1];

    memcpy(*buffer, str.utf16(), str.length() * sizeof(wchar_t));

    (*buffer)[str.length()] = 0;

}

MapiFolderIterator::MapiFolderIterator()

    :_store(0)

{

}

MapiFolderIterator::MapiFolderIterator(MapiStorePtr store, 

                                       MapiFolderPtr root, 

                                       QSet<QMessage::StandardFolder> standardFoldersInclude, 

                                       QSet<QMessage::StandardFolder> standardFoldersExclude,

                                       FolderIdSet parentInclude,

                                       FolderIdSet parentExclude,

                                       FolderIdSet ancestorInclude,

                                       FolderIdSet ancestorExclude)

    :_store(store), 

    _standardFoldersInclude(standardFoldersInclude), 

    _standardFoldersExclude(standardFoldersExclude),

    _parentInclude(parentInclude),

    _parentExclude(parentExclude),

    _ancestorInclude(ancestorInclude),

    _ancestorExclude(ancestorExclude)

{

    QList<MapiFolderPtr> unprocessed;

    if (root && root->isValid())

        unprocessed.append(root);

    while (_store && _store->isValid() && !unprocessed.isEmpty()) {

        MapiFolderPtr parent(unprocessed.takeLast());

        if (parent->isValid()) {

            if (!_store->session()->equal(parent->entryId(), root->entryId()))

                _folders.append(parent);

            QMessageManager::Error ignored(QMessageManager::NoError);

            while (true) {

                MapiFolderPtr folder(parent->nextSubFolder(&ignored));

                if (ignored != QMessageManager::NoError) {

                    qWarning() << "MapiFolderIterator:: Error getting next subfolder";

                    break;

                }

                if (folder && folder->isValid()) {

                    unprocessed.append(folder);

                } else {

                    if (folder) {

                        qWarning() << "MaiFolderIterator:: Invalid subfolder:" << folder->name();

                    }

                    break; // No more subfolders in the current folder

                }

            }

        } else {

            qWarning() << "Invalid folder:" << parent->name();

        }

    }

}

static bool sFolderMatches(MapiFolderPtr folder,

                           QSet<QMessage::StandardFolder> standardFoldersInclude, 

                           QSet<QMessage::StandardFolder> standardFoldersExclude,

                           FolderIdSet parentInclude,

                           FolderIdSet parentExclude,

                           FolderIdSet ancestorInclude,

                           FolderIdSet ancestorExclude)

{

    if (!folder || !folder->isValid()) {

        if (folder) {

            qWarning() << "MaiFolderIterator::next() Invalid subfolder:" << folder->name();

        }

        return false;

    }

    if (!standardFoldersInclude.isEmpty() || !standardFoldersExclude.isEmpty()) {

        QMessage::StandardFolder folderType(folder->standardFolder());

        if (!(standardFoldersInclude.isEmpty() || standardFoldersInclude.contains(folderType))

            || standardFoldersExclude.contains(folderType))

            return false;

    }

    if (!parentInclude.isEmpty() || !parentExclude.isEmpty()) {

        QMessageFolderId parentId(folder->parentId());

#ifndef QSTRING_FOLDER_ID

        if (!(parentInclude.isEmpty() || parentInclude.contains(folder->id()))

            || parentExclude.contains(folder->id()))

            return false;

#else

        QString path(folder->accountId().toString() + "/" + QMessageFolder(folder->id()).path());

        if (!(parentInclude.isEmpty() || parentInclude.contains(path))

            || parentExclude.contains(path))

            return false;

#endif

    }

    if (!ancestorInclude.isEmpty() || !ancestorExclude.isEmpty()) {

        FolderIdSet folderAncestors;

        QMessageFolderId id(folder->parentId());

        while (id.isValid()) {

            QMessageFolder f(id);

#ifndef QSTRING_FOLDER_ID

            folderAncestors.insert(id);

#else

            folderAncestors.insert(f.parentAccountId().toString() + "/" + f.path());

#endif

            id = f.parentFolderId();

        }

        FolderIdSet includeIntersection(ancestorInclude);

        includeIntersection.intersect(folderAncestors);

        FolderIdSet excludeIntersection(ancestorExclude);

        excludeIntersection.intersect(folderAncestors);

        if (!(ancestorInclude.isEmpty() || !includeIntersection.isEmpty())

            || !excludeIntersection.isEmpty()) {

            return false;

        }

    }

    return true;

}

MapiFolderPtr MapiFolderIterator::next()

{

    while (_store && _store->isValid() && !_folders.isEmpty()) {

        MapiFolderPtr folder(_folders.takeFirst());

        if (sFolderMatches(folder, 

                            _standardFoldersInclude, 

                            _standardFoldersExclude, 

                            _parentInclude, 

                            _parentExclude, 

                            _ancestorInclude, 

                            _ancestorExclude)) {

            return folder;

        }

    }

    return MapiFolderPtr();

}

MapiStoreIterator::MapiStoreIterator()

{

}

MapiStoreIterator::MapiStoreIterator(QList<MapiStorePtr> stores, QSet<QMessageAccountId> accountsInclude, QSet<QMessageAccountId> accountsExclude)

    :_stores(stores), _accountsInclude(accountsInclude), _accountsExclude(accountsExclude)

{

}

static bool sAccountIdMatches(QMessageAccountId key, 

                              QSet<QMessageAccountId> accountsInclude, 

                              QSet<QMessageAccountId> accountsExclude)

{

    if ((accountsInclude.isEmpty() || accountsInclude.contains(key))

        && (accountsExclude.isEmpty() || !accountsExclude.contains(key))) {

        return true;

    }

    return false;

}

MapiStorePtr MapiStoreIterator::next()

{

    while (!_stores.isEmpty()) {

        MapiStorePtr store(_stores.takeFirst());

#ifdef _WIN32_WCE

        QMessageAccountId key(QMessageAccountIdPrivate::from(store->entryId()));

#else

        QMessageAccountId key(QMessageAccountIdPrivate::from(store->recordKey()));

#endif

        if (sAccountIdMatches(key, _accountsInclude, _accountsExclude))

            return store;

    }

    return MapiStorePtr();

}

QMessageFilter QMessageFilterPrivate::from(QMessageFilterPrivate::Field field, const QVariant &value, QMessageDataComparator::EqualityComparator cmp)

{

    QMessageFilter result;

    result.d_ptr->_field = field;

    result.d_ptr->_value = value;

    result.d_ptr->_comparatorType = Equality;

    result.d_ptr->_comparatorValue = static_cast<int>(cmp);

    return result;

}

QMessageFilter QMessageFilterPrivate::from(QMessageFilterPrivate::Field field, const QVariant &value, QMessageDataComparator::RelationComparator cmp)

{

    QMessageFilter result;

    result.d_ptr->_field = field;

    result.d_ptr->_value = value;

    result.d_ptr->_comparatorType = Relation;

    result.d_ptr->_comparatorValue = static_cast<int>(cmp);

    return result;

}

QMessageFilter QMessageFilterPrivate::from(QMessageFilterPrivate::Field field, const QVariant &value, QMessageDataComparator::InclusionComparator cmp)

{

    QMessageFilter result;

    result.d_ptr->_field = field;

    result.d_ptr->_value = value;

    result.d_ptr->_comparatorType = Inclusion;

    result.d_ptr->_comparatorValue = static_cast<int>(cmp);

    return result;

}

QMessageFilterPrivate* QMessageFilterPrivate::implementation(const QMessageFilter &filter)

{

    return filter.d_ptr;

}

MapiFolderIterator QMessageFilterPrivate::folderIterator(const QMessageFilter &filter, QMessageManager::Error *error, const MapiStorePtr &store)

{

    return MapiFolderIterator(store, 

        store->rootFolder(error),

        filter.d_ptr->_standardFoldersInclude, 

        filter.d_ptr->_standardFoldersExclude,

        filter.d_ptr->_parentInclude, 

        filter.d_ptr->_parentExclude,

        filter.d_ptr->_ancestorInclude, 

        filter.d_ptr->_ancestorExclude);

}

MapiStoreIterator QMessageFilterPrivate::storeIterator(const QMessageFilter &filter, QMessageManager::Error *error, const MapiSessionPtr &session)

{

    return MapiStoreIterator(session->allStores(error), filter.d_ptr->_accountsInclude, filter.d_ptr->_accountsExclude);

}

QList<QMessageFilter> QMessageFilterPrivate::subfilters(const QMessageFilter &filter)

{

    QList<QMessageFilter> result;

    QList<QMessageFilter> queue;

    queue.append(filter);

    while (!queue.isEmpty()) {

        QMessageFilter top(queue.takeFirst());

        if (!top.d_ptr->_complex) {

            result.append(top);

            continue;

        }

        // Complex so must consist of two subfilters or'd together and an empty containerFiltersPart

        queue.append(*top.d_ptr->_left);

        queue.append(*top.d_ptr->_right);

    }

    return result;

}

// Several filters require QMessageManager::queryX to be called to evaluate filter member variables, 

// namely byIds(const QMessageFilter &, ...), byParentAccountId(const QMessageAccountFilter &, ...), 

// byFolderIds(const QMessageFolderFilter &, ...), byAncestorFolderIds(const QMessageFolderFilter &, ...)

QMessageFilter QMessageFilterPrivate::preprocess(QMessageManager::Error *error, MapiSessionPtr session, const QMessageFilter &filter)

{

    QMessageFilter result(filter);

    QMessageFilterPrivate::preprocess(error, session, &result);

    return result;

}

// returns true if filter is modified

bool QMessageFilterPrivate::preprocess(QMessageManager::Error *error, MapiSessionPtr session, QMessageFilter *filter)

{

    if (!filter)

        return false;

    // incl only used if filter->d_ptr->field is == *Filter

    QMessageDataComparator::InclusionComparator incl(static_cast<QMessageDataComparator::InclusionComparator>(filter->d_ptr->_comparatorValue));

    bool inclusion(incl == QMessageDataComparator::Includes);

    QMessageFilter result;

    if (filter->d_ptr->_operator == Not) {

        inclusion = !inclusion;

    }

    if (inclusion) {

        result = ~QMessageFilter();

    }

    if (filter->d_ptr->_field == MessageFilter) {

        if (filter->d_ptr->_messageFilter->isEmpty()) {

            result = ~result;  // match all for include, match none for exclude

        } else {

            QMessageIdList ids(session->queryMessages(error, *filter->d_ptr->_messageFilter));

            result = QMessageFilter::byId(ids, inclusion ? QMessageDataComparator::Includes : QMessageDataComparator::Excludes);

        }

    } else if (filter->d_ptr->_field == AccountFilter) {

        if (filter->d_ptr->_accountFilter->isEmpty()) {

            result = ~result;  // match all for include, match none for exclude

        } else {

            QList<MapiStorePtr> stores(session->filterStores(error, *filter->d_ptr->_accountFilter));

            foreach(MapiStorePtr store, stores) {

                if (inclusion) {

                    result |= QMessageFilter::byParentAccountId(store->id());

                } else {

                    result &= QMessageFilter::byParentAccountId(store->id(), QMessageDataComparator::NotEqual);

                }

            }

        }

    } else if (filter->d_ptr->_field == FolderFilter) {

        if (filter->d_ptr->_folderFilter->isEmpty()) {

            result = ~result;  // match all for include, match none for exclude

        } else {

            QList<MapiFolderPtr> folders(session->filterFolders(error, *filter->d_ptr->_folderFilter));

            foreach(MapiFolderPtr folder, folders) {

                if (inclusion) {

                    result |= QMessageFilter::byParentFolderId(folder->id());

                } else {

                    result &= QMessageFilter::byParentFolderId(folder->id(), QMessageDataComparator::NotEqual);

                }

            }

        }

    } else if (filter->d_ptr->_field == AncestorFilter) {

        QList<MapiFolderPtr> folders(session->filterFolders(error, *filter->d_ptr->_folderFilter));

        foreach(MapiFolderPtr folder, folders) {

            if (inclusion) {

                result |= QMessageFilter::byAncestorFolderIds(folder->id());

            } else {

                result &= QMessageFilter::byAncestorFolderIds(folder->id(), QMessageDataComparator::Excludes);

            }

        }

    } else {

        QMessageFilter *l(filter->d_ptr->_left);

        QMessageFilter *r(filter->d_ptr->_right);

        bool modified(true); //TODO: should default to false but tst_qmessagestorekeys (id list exclusion 3) is failing

        modified |= preprocess(error, session, l);

        modified |= preprocess(error, session, r);

        // It's necessary to recombine bool op filters, because the operands may now have non-empty containerFilter parts,

        // specifically in the case that one of the operands has a *Filter field.

        if (modified) {

            switch (filter->d_ptr->_operator) {

            case And:

                *filter = filter->d_ptr->containerFiltersPart() & (*l & *r);

                break;

            case Nand:

                *filter = filter->d_ptr->containerFiltersPart() &  ~(*l & *r);

                break;

            case Or:

                *filter = filter->d_ptr->containerFiltersPart() &  (*l | *r);

                break;

            case Nor:

                *filter = filter->d_ptr->containerFiltersPart() &  ~(*l | *r);

                break;

            }

        }

        return modified;

    }

    *filter = filter->d_ptr->containerFiltersPart() & result; // Must preserve container filters part

    return true;

}

bool QMessageFilterPrivate::restrictionPermitted(const QMessageFilter &filter)

{

    bool result(filter.d_ptr->_restrictionPermitted);

    if (filter.d_ptr->_left)

        result &= QMessageFilterPrivate::restrictionPermitted(*filter.d_ptr->_left);

    if (filter.d_ptr->_right)

        result &= QMessageFilterPrivate::restrictionPermitted(*filter.d_ptr->_right);

    return result;

}

bool QMessageFilterPrivate::matchesMessageRequired(const QMessageFilter &filter)

{

    bool result(filter.d_ptr->_matchesRequired);

    if (filter.d_ptr->_left)

        result |= QMessageFilterPrivate::matchesMessageRequired(*filter.d_ptr->_left);

    if (filter.d_ptr->_right)

        result |= QMessageFilterPrivate::matchesMessageRequired(*filter.d_ptr->_right);

    return result;

}

bool QMessageFilterPrivate::containsSenderSubfilter(const QMessageFilter &filter)

{

    bool result(filter.d_ptr->_field == QMessageFilterPrivate::Sender);

    if (filter.d_ptr->_left)

        result |= QMessageFilterPrivate::containsSenderSubfilter(*filter.d_ptr->_left);

    if (filter.d_ptr->_right)

        result |= QMessageFilterPrivate::containsSenderSubfilter(*filter.d_ptr->_right);

    return result;

}

bool QMessageFilterPrivate::isNonMatching(const QMessageFilter &filter)

{

    return (filter.d_ptr->containerFiltersAreEmpty() 

        && (filter.d_ptr->_field == QMessageFilterPrivate::None)

        && (filter.d_ptr->_operator == QMessageFilterPrivate::Not));

}

bool QMessageFilterPrivate::matchesMessage(const QMessageFilter &filter, const QMessage &message, MapiStore *store)

{

    if (filter.isEmpty())

        return true;

    QMessageAccountId accountId(message.parentAccountId());

    if (!sAccountIdMatches(accountId, filter.d_ptr->_accountsInclude, filter.d_ptr->_accountsExclude))

        return false;

    QMessageManager::Error ignoredError(QMessageManager::NoError);

#ifdef _WIN32_WCE

    MapiFolderPtr folder = store->openFolder(&ignoredError, QMessageIdPrivate::folderRecordKey(message.id()));

#else

    MapiFolderPtr folder = store->openFolderWithKey(&ignoredError, QMessageIdPrivate::folderRecordKey(message.id()));

#endif

    if (ignoredError != QMessageManager::NoError)

        return false;

    if (!sFolderMatches(folder, 

        filter.d_ptr->_standardFoldersInclude, 

        filter.d_ptr->_standardFoldersExclude,

        filter.d_ptr->_parentInclude, 

        filter.d_ptr->_parentExclude,

        filter.d_ptr->_ancestorInclude, 

        filter.d_ptr->_ancestorExclude))

        return false;

    return matchesMessageSimple(filter, message);

}

// Simple matchesMessage function, filter must have an empty nonContainerFiltersPart

bool QMessageFilterPrivate::matchesMessageSimple(const QMessageFilter &filter, const QMessage &message)

{

    bool negate(false);

    bool result(true);

    if (!filter.d_ptr->_valid) {

        qWarning("matchesMessage: Invalid filter application attempted.");

        return false;

    }

    if (filter.d_ptr->_matchFlags & QMessageDataComparator::MatchFullWord) {

        // TODO: Document Full word matching is not supported on MAPI

        qWarning("matchesMessage: Full word matching not supported on MAPI platforms.");

        return false;

    }

    switch (filter.d_ptr->_operator) {

    case QMessageFilterPrivate::Not: // fall through

    case QMessageFilterPrivate::Nand: // fall through

    case QMessageFilterPrivate::Nor:

        negate = true;

        break;

    default:

        break;

    } //end switch

    switch (filter.d_ptr->_operator) {

    case QMessageFilterPrivate::And: // fall through

    case QMessageFilterPrivate::Nand:

        result = matchesMessageSimple(*filter.d_ptr->_left, message) 

            && matchesMessageSimple(*filter.d_ptr->_right, message);

        break;

    case QMessageFilterPrivate::Nor: // fall through

    case QMessageFilterPrivate::Or:

        result = matchesMessageSimple(*filter.d_ptr->_left, message) 

            || matchesMessageSimple(*filter.d_ptr->_right, message);

        break;

    case QMessageFilterPrivate::Not: // fall through

    case QMessageFilterPrivate::Identity: {

        switch (filter.d_ptr->_field) {

        case QMessageFilterPrivate::None:

            break;

        case QMessageFilterPrivate::Recipients: // fall through

        case QMessageFilterPrivate::Sender: // fall through

        case QMessageFilterPrivate::Subject: {

            QString value(filter.d_ptr->_value.toString());

            QStringList messageStrings;

            QString tmp;