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

**

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

QTM_BEGIN_NAMESPACE

QMessageFilterPrivate::QMessageFilterPrivate(QMessageFilter *messageFilter)

 : q_ptr(messageFilter),

   _valid(true),

   _field(None),

   _comparatorType(Equality),

   _comparatorValue(QMessageDataComparator::Equal)

{

}

QMessageFilterPrivate::~QMessageFilterPrivate()

{

}

bool QMessageFilterPrivate::lessThan(const QMessageFilter filter1, const QMessageFilter filter2)

{

    if (filter1.d_ptr->_field == filter2.d_ptr->_field) {

        if (filter1.d_ptr->_comparatorType == filter2.d_ptr->_comparatorType) {

            return filter1.d_ptr->_comparatorValue < filter2.d_ptr->_comparatorValue;

        }

        return filter1.d_ptr->_comparatorType < filter2.d_ptr->_comparatorType;

    }

    return filter1.d_ptr->_field < filter2.d_ptr->_field;

}

void QMessageFilterPrivate::changeComparatorValuesToOpposite(QMessageFilter& filter)

{

    if (filter.d_ptr->_filterList.count() == 0) {

        if (filter.d_ptr->_comparatorType == QMessageFilterPrivate::Equality) {

            QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter.d_ptr->_comparatorValue));

            if (cmp == QMessageDataComparator::Equal) {

                filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::NotEqual);

            } else {

                filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::Equal);

            }

        } else if (filter.d_ptr->_comparatorType == QMessageFilterPrivate::Relation) {

            QMessageDataComparator::RelationComparator cmp(static_cast<QMessageDataComparator::RelationComparator>(filter.d_ptr->_comparatorValue));

            if (cmp == QMessageDataComparator::LessThan) {

                filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::GreaterThanEqual);

            } else if (cmp == QMessageDataComparator::LessThanEqual) {

                filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::GreaterThan);

            } else if (cmp == QMessageDataComparator::GreaterThan) {

                filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::LessThanEqual);

            } else { // GreaterThanEqual

                filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::LessThan);

            }

        } else { // Inclusion

            if (filter.d_ptr->_field == QMessageFilterPrivate::Status) {

                if (!filter.d_ptr->_value.isNull()) {

                    filter.d_ptr->_notFilterForComparator = !filter.d_ptr->_notFilterForComparator;

                } else {

                    filter.d_ptr->_notFilter = !filter.d_ptr->_notFilter;

                }

            } else {

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

                if (cmp == QMessageDataComparator::Includes) {

                    filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::Excludes);

                } else { // Excludes

                    filter.d_ptr->_comparatorValue = static_cast<int>(QMessageDataComparator::Includes);

                }

            }

        }

    } else {

        for (int i=0; i < filter.d_ptr->_filterList.count(); i++) {

            for (int j=0; j < filter.d_ptr->_filterList[i].count(); j++) {

                QMessageFilterPrivate::changeComparatorValuesToOpposite(filter.d_ptr->_filterList[i][j]);

            }

        }

    }

}

void QMessageFilterPrivate::changeANDsAndORsToOpposite(QMessageFilter& filter)

{

    if (filter.d_ptr->_filterList.count() > 0) {

        QMessageFilter oldFilter = filter;

        filter.d_ptr->_filterList.clear();

        for (int i=0; i < oldFilter.d_ptr->_filterList.count(); i++) {

            if (i == 0) {

                for (int j=0; j < oldFilter.d_ptr->_filterList[i].count(); j++) {

                    if (j == 0) {

                        filter.d_ptr->_filterList.append(QMessageFilterPrivate::SortedMessageFilterList());

                        filter.d_ptr->_filterList[0] << QMessageFilter(oldFilter.d_ptr->_filterList[i][j]);

                    } else {

                        filter |= oldFilter.d_ptr->_filterList[i][j];

                    }

                }

            } else {

                QMessageFilter tempFilter;

                for (int j=0; j < oldFilter.d_ptr->_filterList[i].count(); j++) {

                    if (j == 0) {

                        tempFilter = oldFilter.d_ptr->_filterList[i][j];

                    } else {

                        tempFilter |= oldFilter.d_ptr->_filterList[i][j];

                    }

                }

                filter &= tempFilter;

            }

        }

        for (int i=0; i < filter.d_ptr->_filterList.count(); i++) {

            qSort(filter.d_ptr->_filterList[i].begin(), filter.d_ptr->_filterList[i].end(), QMessageFilterPrivate::lessThan);

        }

    }

}

void QMessageFilterPrivate::applyNot(QMessageFilter& filter)

{

    QMessageFilterPrivate::changeComparatorValuesToOpposite(filter);

    QMessageFilterPrivate::changeANDsAndORsToOpposite(filter);

}

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

{

    if ((filter._field == QMessageFilterPrivate::None) &&

        (filter._filterList.count() == 0)) {

        if (filter._notFilter) {

            return false;

        } else {

            return true;

        }

    }

    Qt::CaseSensitivity caseSensitivity = (filter._matchFlags & QMessageDataComparator::MatchCaseSensitive) ? Qt::CaseSensitive : Qt::CaseInsensitive;

    switch (filter._field) {

    case QMessageFilterPrivate::Id:

        {

        if (filter._comparatorType == QMessageFilterPrivate::Equality) {

            QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::Equal) {

                if (message.id().toString() == filter._value.toString()) {

                    return true;

                }

            } else { // NotEqual

                if (message.id().toString() != filter._value.toString()) {

                    return true;

                }

            }

        } else if (filter._comparatorType == QMessageFilterPrivate::Inclusion) {

            QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

            if (filter._ids.count() > 0) { // QMessageIdList

               if (cmp == QMessageDataComparator::Includes) {

                   if (filter._ids.contains(message.id())) {

                       return true;

                   }

               } else { // Excludes

                   if (!filter._ids.contains(message.id())) {

                       return true;

                   }

               }

            } else { // QMessageFilter

               if (cmp == QMessageDataComparator::Includes) {

                   // TODO:

               } else { // Excludes

                   // TODO:

               }

            }

        }

        break;

        }

    case QMessageFilterPrivate::Type:

        {

        QMessage::Type type = static_cast<QMessage::Type>(filter._value.toInt());

        if (filter._comparatorType == QMessageFilterPrivate::Equality) {

            QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::Equal) {

                if (message.type() == type) {

                    return true;

                }

            } else { // NotEqual

                if (message.type() != type) {

                    return true;

                }

            }

        } else if (filter._comparatorType == QMessageFilterPrivate::Inclusion) {

            QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::Includes) {

                if ((message.type() & type) == message.type()) {

                    return true;

                }

            } else { // Excludes

            if ((message.type() & type) == 0) {

                    return true;

                }

            }

        }

        break;

        }

    case QMessageFilterPrivate::Sender:

        {

        if (filter._comparatorType == QMessageFilterPrivate::Equality) {

            QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::Equal) {

                if (filter._value.toString().length() > 0) {

                        return true;

                    }

                }

            } else { // NotEqual

                if (filter._value.toString().length() > 0) {

                        return true;

                    }

                } else {

                    return true;

                }

            }

        } else if (filter._comparatorType == QMessageFilterPrivate::Inclusion) {

            QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::Includes) {

                    return true;

                }

            } else { // Excludes

                    return true;

                }

            }

        }

        break;

        }

    case QMessageFilterPrivate::Recipients: // to, cc & bcc fields

        {

        if (filter._comparatorType == QMessageFilterPrivate::Inclusion) {

            QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

            bool includes = false;

            // Check to addresses

            QMessageAddressList addrList = message.to();

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

                    includes = true;

                    break;

                }

            }

            if (!includes) {

                // Check cc addresses

                addrList = message.cc();

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

                        includes = true;

                        break;

                    }

                }

            }

            if (!includes) {

                // Check bcc addresses

                addrList = message.bcc();

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

                        includes = true;

                        break;

                    }

                }

            }

            if (cmp == QMessageDataComparator::Includes) {

                if (includes) {

                    return true;

                }

            } else { // Excludes

                if (!includes) {

                    return true;

                }

            }

        }

        break;

        }

    case QMessageFilterPrivate::Subject:

        {

        if (filter._comparatorType == QMessageFilterPrivate::Equality) {

            QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::Equal) {

                if (filter._value.toString().length() > 0) {

                    if (message.subject().compare(filter._value.toString(),caseSensitivity) == 0) {

                        return true;

                    }

                }

            } else { // NotEqual

                if (filter._value.toString().length() > 0) {

                    if (message.subject().compare(filter._value.toString(),caseSensitivity) != 0) {

                        return true;

                    }

                } else {

                    return true;

                }

            }

        } else if (filter._comparatorType == QMessageFilterPrivate::Inclusion) {

            QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::Includes) {

                if (message.subject().contains(filter._value.toString(),caseSensitivity)) {

                    return true;

                }

            } else { // Excludes

            if (!message.subject().contains(filter._value.toString(),caseSensitivity)) {

                    return true;

                }

            }

        }

        break;

        }

    case QMessageFilterPrivate::TimeStamp:

        {

        if (filter._comparatorType == QMessageFilterPrivate::Equality) {

            QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::Equal) {

                if (message.date() == filter._value.toDateTime()) {

                    return true;

                }

            } else { // NotEqual

                if (message.date() != filter._value.toDateTime()) {

                    return true;

                }

            }

        } else if (filter._comparatorType == QMessageFilterPrivate::Relation) {

            QMessageDataComparator::RelationComparator cmp(static_cast<QMessageDataComparator::RelationComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::LessThan) {

                if (message.date() < filter._value.toDateTime()) {

                    return true;

                }

            } else if (cmp == QMessageDataComparator::LessThanEqual) {

                if (message.date() <= filter._value.toDateTime()) {

                    return true;

                }

            } else if (cmp == QMessageDataComparator::GreaterThan) {

                if (message.date() > filter._value.toDateTime()) {

                    return true;

                }

            } else { // GreaterThanEqual

                if (message.date() >= filter._value.toDateTime()) {

                    return true;

                }

            }

        }

        break;

        }

    case QMessageFilterPrivate::ReceptionTimeStamp:

        {

        if (filter._comparatorType == QMessageFilterPrivate::Equality) {

            QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::Equal) {

                if (message.date() == filter._value.toDateTime()) {

                    return true;

                }

            } else { // NotEqual

                if (message.date() != filter._value.toDateTime()) {

                    return true;

                }

            }

        } else if (filter._comparatorType == QMessageFilterPrivate::Relation) {

            QMessageDataComparator::RelationComparator cmp(static_cast<QMessageDataComparator::RelationComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::LessThan) {

                if (message.receivedDate() < filter._value.toDateTime()) {

                    return true;

                }

            } else if (cmp == QMessageDataComparator::LessThanEqual) {

                if (message.receivedDate() <= filter._value.toDateTime()) {

                    return true;

                }

            } else if (cmp == QMessageDataComparator::GreaterThan) {

                if (message.receivedDate() > filter._value.toDateTime()) {

                    return true;

                }

            } else { // GreaterThanEqual

                if (message.receivedDate() >= filter._value.toDateTime()) {

                    return true;

                }

            }

        }

        break;

        }

    case QMessageFilterPrivate::Status:

        {

        if (filter._comparatorType == QMessageFilterPrivate::Equality) {

            QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

            if (filter._value.toInt() == 0) {

                if (cmp == QMessageDataComparator::Equal) {

                    return false;

                } else {

                    return true;

                }

            }

            QMessage::Status status = static_cast<QMessage::Status>(filter._value.toInt());

            if (cmp == QMessageDataComparator::Equal) {

                if ((message.status() & status) == status) {

                    return true;

                }

            } else { // NotEqual

                if (!((message.status() & status) == status)) {

                    return true;

                }

            }

        } else if (filter._comparatorType == QMessageFilterPrivate::Inclusion) {

            QMessageDataComparator::InclusionComparator cmp(static_cast<QMessageDataComparator::InclusionComparator>(filter._comparatorValue));

            if (filter._value.toInt() == 0) {

                if (cmp == QMessageDataComparator::Includes) {

                    if (filter._notFilterForComparator) {

                        return true;

                    } else {

                        return false;

                    }

                } else {

                    if (filter._notFilterForComparator) {

                        return true;

                    } else {

                        return false;

                    }

                }

            }

            if (cmp == QMessageDataComparator::Includes) {

                if ((message.status() | filter._value.toInt()) == message.status()) {

                    if (filter._notFilterForComparator) {

                        return false;

                    } else {

                        return true;

                    }

                } else {

                    if (filter._notFilterForComparator) {

                        return true;

                    }

                }

            } else { // Excludes

                int mask = 15 - filter._value.toInt(); // 15 = 0b1111

                if ((message.status() & mask) == message.status()) {

                    if (filter._notFilterForComparator) {

                        return false;

                    } else {

                        return true;

                    }

                } else {

                    if (filter._notFilterForComparator) {

                        return true;

                    }

                }

            }

        }

        break;

        }

    case QMessageFilterPrivate::Priority:

        {

        QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

        if (cmp == QMessageDataComparator::Equal) {

            if (message.priority() == filter._value.toInt()) {

                return true;

            }

        } else { // NotEqual

            if (message.priority() != filter._value.toInt()) {

                return true;

            }

        }

        break;

        }

    case QMessageFilterPrivate::Size:

        {

        if (filter._comparatorType == QMessageFilterPrivate::Equality) {

            QMessageDataComparator::EqualityComparator cmp(static_cast<QMessageDataComparator::EqualityComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::Equal) {

                    return true;

                }

            } else { // NotEqual

                    return true;

                }

            }

        } else if (filter._comparatorType == QMessageFilterPrivate::Relation) {

            QMessageDataComparator::RelationComparator cmp(static_cast<QMessageDataComparator::RelationComparator>(filter._comparatorValue));

            if (cmp == QMessageDataComparator::LessThan) {

                    return true;

                }

            } else if (cmp == QMessageDataComparator::LessThanEqual) {

                    return true;

                }

            } else if (cmp == QMessageDataComparator::GreaterThan) {

                    return true;

                }

            } else { // GreaterThanEqual

                    return true;

                }

            }