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

**

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

#include "qmessageservice_symbian_p.h"

#include "qfsengine_symbian_p.h"

#include "qmessage_symbian_p.h"

#include "messagingutil_p.h"

#include "qmessageaccount.h"

#include "qmessageaccount_p.h"

#include "qmessageaccountfilter.h"

#include "qmessageaccountfilter_p.h"

#include "qmessagecontentcontainer_symbian_p.h"

#include "qmessagefolder.h"

#include "qmessagefolder_p.h"

#include "qmessagefolderfilter.h"

#include "qmessagefolderfilter_p.h"

#include "qmessageaccountsortorder_p.h"

#include "qmessagestore_symbian_p.h"

#include "qmessagefoldersortorder_p.h"

#include "qmessagesortorder_p.h"

#include <emailinterfacefactory.h>

#include <QTextCodec>

#include <emailapidefs.h>

#include <memailmailbox.h>

#include <memailfolder.h>

#include <memailmessage.h>

#include <memailaddress.h>

#include <memailcontent.h>

#include <mmessageiterator.h>

using namespace EmailInterface;

QTM_BEGIN_NAMESPACE

using namespace SymbianHelpers;

Q_GLOBAL_STATIC(CFSEngine,fsEngine);

CFSEngine::CFSEngine()

{

    connect(QCoreApplication::instance(), SIGNAL(aboutToQuit()), this, SLOT(cleanupFSBackend()));

    TRAPD(err, {

        m_factory = CEmailInterfaceFactory::NewL(); 

        m_ifPtr = m_factory->InterfaceL(KEmailClientApiInterface);

    });

    Q_UNUSED(err);

    m_clientApi = static_cast<MEmailClientApi*>(m_ifPtr);

#ifdef FREESTYLEMAILBOXOBSERVERUSED

    TRAPD(err2, setPluginObserversL());

    Q_UNUSED(err2);

#endif

}

CFSEngine::~CFSEngine()

{

}

void CFSEngine::cleanupFSBackend()

{

    m_mtmAccountList.clear();

    for (TInt i = 0; i < m_attachments.Count(); i++){

        m_attachments[i]->Release();

    }

    m_attachments.Reset();

    for (TInt i = 0; i < m_mailboxes.Count(); i++){

        m_mailboxes[i]->Release();

    }

    m_mailboxes.Reset();

    m_clientApi->Release();

    delete m_factory;

}

CFSEngine* CFSEngine::instance()

{   

    return fsEngine();

}

bool CFSEngine::accountLessThan(const QMessageAccountId accountId1, const QMessageAccountId accountId2)

{

    CFSEngine* freestyleEngine = fsEngine();

    return QMessageAccountSortOrderPrivate::lessThan(freestyleEngine->m_currentAccountOrdering,

        freestyleEngine->account(accountId1),

        freestyleEngine->account(accountId2));

}

void CFSEngine::orderAccounts(QMessageAccountIdList& accountIds, const QMessageAccountSortOrder &sortOrder) const

{

    Q_UNUSED(accountIds);

    m_currentAccountOrdering = sortOrder;

    qSort(accountIds.begin(), accountIds.end(), CFSEngine::accountLessThan);

}

bool CFSEngine::folderLessThan(const QMessageFolderId folderId1, const QMessageFolderId folderId2)

{

    CFSEngine* freestyleEngine = fsEngine();

    return QMessageFolderSortOrderPrivate::lessThan(freestyleEngine->m_currentFolderOrdering,

            freestyleEngine->folder(folderId1),

            freestyleEngine->folder(folderId2));

}

void CFSEngine::orderFolders(QMessageFolderIdList& folderIds,  const QMessageFolderSortOrder &sortOrder) const

{

    m_currentFolderOrdering = sortOrder;

    qSort(folderIds.begin(), folderIds.end(), CFSEngine::folderLessThan);

}

bool CFSEngine::messageLessThan(const QMessage& message1, const QMessage& message2)

{

    CFSEngine* freestyleEngine = fsEngine();

    return QMessageSortOrderPrivate::lessThan(freestyleEngine->m_currentMessageOrdering, message1, message2);

}

void CFSEngine::orderMessages(QMessageIdList& messageIds, const QMessageSortOrder &sortOrder) const

{

    m_currentMessageOrdering = sortOrder;

    QList<QMessage> messages;

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

        messages.append(message(messageIds[i]));

    }

    qSort(messages.begin(), messages.end(), CFSEngine::messageLessThan);

    messageIds.clear();

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

        messageIds.append(messages[i].id());

    }

}

void CFSEngine::setMtmAccountIdList(QMessageAccountIdList accountList)

{

    for (TInt i = 0; i < accountList.count(); i++) {

        m_mtmAccountList.append(stripIdPrefix(accountList[i]));

    }

}

QMessageAccountIdList CFSEngine::queryAccounts(const QMessageAccountFilter &filter, const QMessageAccountSortOrder &sortOrder, uint limit, uint offset) const

{

    QMessageAccountIdList accountIds;

    TRAPD(err, updateEmailAccountsL());

    Q_UNUSED(err);

    QMessageAccountFilterPrivate* privateMessageAccountFilter = QMessageAccountFilterPrivate::implementation(filter);

    if (filter.isEmpty()) {

        if (!privateMessageAccountFilter->_notFilter) {

            // All accounts are returned for empty filter

            foreach (QMessageAccount value, m_accounts) {                

                accountIds.append(value.id());

            }

        }

    } else {

        if (privateMessageAccountFilter->_valid) {

            foreach (QMessageAccount value, m_accounts) {

                if (privateMessageAccountFilter->filter(value)) {

                    accountIds.append(value.id());

                }

            }

        } else {

            foreach (QMessageAccount value, m_accounts) {

                if (privateMessageAccountFilter->filter(value)) {

                    accountIds.append(value.id());

                }

            }

        }

    }

    if (!sortOrder.isEmpty()) {

        orderAccounts(accountIds, sortOrder);

    }

    applyOffsetAndLimitToAccountIds(accountIds, offset, limit);

    return accountIds;

}

void CFSEngine::applyOffsetAndLimitToAccountIds(QMessageAccountIdList& idList, int offset, int limit) const

{

    if (offset > 0) {

        if (offset > idList.count()) {

            idList.clear();

        } else {

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

                idList.removeFirst();

            }

        }

    }

    if (limit > 0) {

        for (int i = idList.count()-1; i >= limit; i--) {

            idList.removeAt(i);

        }

    }

}

int CFSEngine::countAccounts(const QMessageAccountFilter &filter) const

{

    return queryAccounts(filter, QMessageAccountSortOrder(), 0, 0).count();

}

QMessageAccount CFSEngine::account(const QMessageAccountId &id) const

{

    TRAPD(err, updateEmailAccountsL());

    Q_UNUSED(err)

    return m_accounts[id.toString()];

}

QMessageAccountId CFSEngine::defaultAccount(QMessage::Type type) const

{

    // TODO

    Q_UNUSED(type);

    return QMessageAccountId();

}

QMessageAccountIdList CFSEngine::accountsByType(QMessage::Type type) const

{

    QMessageAccountIdList accountIds = QMessageAccountIdList();

    foreach (QMessageAccount value, m_accounts) {

        if ((value.messageTypes() & type) == (int)type) {

            accountIds.append(value.id());

        }

    }

    return accountIds;

}

void CFSEngine::updateEmailAccountsL() const

{

    QStringList keys = m_accounts.keys();

    RMailboxPtrArray mailboxes;

    CleanupResetAndRelease<MEmailMailbox>::PushL(mailboxes);

    m_clientApi->GetMailboxesL(mailboxes);

    for (TInt i = 0; i < mailboxes.Count(); i++) {

        MEmailMailbox *mailbox = mailboxes[i];

        QString idAsString = QString::number(mailbox->MailboxId().iId);

        QString fsIdAsString = addIdPrefix(idAsString, SymbianHelpers::EngineTypeFreestyle);

        TBool overlap = false;

        for (TInt j = 0; j < m_mtmAccountList.count(); j++) {

            if (idAsString == m_mtmAccountList[j].toString())

                overlap = true;

        }

        if (!m_accounts.contains(fsIdAsString) && !overlap) {     

            QMessageAccount account = QMessageAccountPrivate::from(

                                      QMessageAccountId(fsIdAsString),

                                      QString::fromUtf16(mailbox->MailboxName().Ptr(), mailbox->MailboxName().Length()),

                                      0,

                                      0,

                                      QMessage::Email);

            m_accounts.insert(fsIdAsString, account);

        } else {

            keys.removeOne(fsIdAsString);

        }

        mailbox->Release();

    }  

    mailboxes.Reset();

    CleanupStack::PopAndDestroy();

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

        m_accounts.remove(keys[i]);

    }   

}

#ifdef FREESTYLEMAILBOXOBSERVERUSED

void CFSEngine::setPluginObserversL()

{

    m_clientApi->GetMailboxesL(m_mailboxes);    

    for (TInt i = 0; i < m_mailboxes.Count(); i++) {

        MEmailMailbox *mailbox = m_mailboxes[i];

        mailbox->RegisterObserverL(*this);

    }  

}

void CFSEngine::NewMessageEventL(const TMailboxId& aMailbox, const REmailMessageIdArray aNewMessages, const TFolderId& aParentFolderId)

{

    QMessageManager::NotificationFilterIdSet matchingFilters;

    QMessageStorePrivate::NotificationType notificationType = QMessageStorePrivate::Added;

    for (TInt i = 0; i < aNewMessages.Count(); i++) {

        TMessageId messageId(aNewMessages[i]);

        notificationL(aMailbox, messageId, aParentFolderId, notificationType);

    }

}

void CFSEngine::MessageChangedEventL(const TMailboxId& aMailbox, const REmailMessageIdArray aChangedMessages, const TFolderId& aParentFolderId)

{

    QMessageManager::NotificationFilterIdSet matchingFilters;

    QMessageStorePrivate::NotificationType notificationType = QMessageStorePrivate::Updated;

    for (TInt i = 0; i < aChangedMessages.Count(); i++) {

        TMessageId messageId(aChangedMessages[i]);

        notificationL(aMailbox, messageId, aParentFolderId, notificationType);

    }

}

void CFSEngine::MessageDeletedEventL(const TMailboxId& aMailbox, const REmailMessageIdArray aDeletedMessages, const TFolderId& aParentFolderId)

{

    // TODO: add filter handling

    QMessageManager::NotificationFilterIdSet matchingFilters;

    QMap<int, QMessageFilter> filters(m_filters);

    QMap<int, QMessageFilter>::const_iterator it = filters.begin(), end = filters.end();  

    QMessageStorePrivate::NotificationType notificationType = QMessageStorePrivate::Removed;

    MEmailMailbox* mailbox = m_clientApi->MailboxL(aMailbox);

    MEmailFolder* folder = mailbox->FolderL(aParentFolderId); 

    QString idAsString = QString::number(mailbox->MailboxId().iId);

    for (TInt j = 0; j < m_mtmAccountList.count(); j++) {

        if (idAsString == m_mtmAccountList[j].toString())

            return;

    } 

    for (TInt i = 0; i < aDeletedMessages.Count(); i++) {

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

            // Empty filter matches to all messages

            matchingFilters.insert(it.key());

        }

        TMessageId messageId(aDeletedMessages[i]);

        ipMessageStorePrivate->messageNotification(notificationType, 

                            QMessageId(addIdPrefix(QString::number(messageId.iId), SymbianHelpers::EngineTypeFreestyle)), 

                            matchingFilters);

    }

    folder->Release();

    mailbox->Release();

}

void CFSEngine::notificationL(const TMailboxId& aMailbox, const TMessageId& aMessageId, 

                                const TFolderId& aParentFolderId, QMessageStorePrivate::NotificationType aNotificationType)

{

    Q_UNUSED(aParentFolderId);

    QMessageManager::NotificationFilterIdSet matchingFilters;

    // Copy the filter map to protect against modification during traversal

    QMap<int, QMessageFilter> filters(m_filters);

    QMap<int, QMessageFilter>::const_iterator it = filters.begin(), end = filters.end();

    QMessage message;

    QMessageId realMessageId = QMessageId(addIdPrefix(QString::number(aMessageId.iId), SymbianHelpers::EngineTypeFreestyle));

    bool messageRetrieved = false;    

    MEmailMailbox* mailbox = m_clientApi->MailboxL(aMailbox);

    CleanupReleasePushL(*mailbox);

    QString idAsString = QString::number(mailbox->MailboxId().iId);

    for (TInt j = 0; j < m_mtmAccountList.count(); j++) {

        if (idAsString == m_mtmAccountList[j].toString()) {

            CleanupStack::Pop(mailbox);

            return;

        }

    }   

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

        const QMessageFilter &filter(it.value());

        if (!messageRetrieved) {

            MEmailMessage* fsMessage = mailbox->MessageL(aMessageId);

            CleanupReleasePushL(*fsMessage);

            if (!fsMessage) {

                CleanupStack::Pop(fsMessage);

                CleanupStack::Pop(mailbox);

                return;

            }

            message = CreateQMessageL(fsMessage);

            messageRetrieved = true;

            CleanupStack::Pop(fsMessage);

        }

        if (filter.isEmpty()) {

            // Empty filter matches to all messages

            matchingFilters.insert(it.key());

        } else {

            if (message.type() == QMessage::NoType) {

                matchingFilters.clear();

                continue;

            }

        }

        QMessageFilterPrivate* privateMessageFilter = QMessageFilterPrivate::implementation(filter);

        if (privateMessageFilter->filter(message)) {

            matchingFilters.insert(it.key());

        }

    }

    int c = matchingFilters.count();

    QString id = realMessageId.toString();

    if (matchingFilters.count() > 0)

        ipMessageStorePrivate->messageNotification(aNotificationType, realMessageId, matchingFilters);

    CleanupStack::Pop(mailbox);   

}

#endif

MEmailMessage* CFSEngine::createFSMessageL(const QMessage &message, const MEmailMailbox* mailbox)

{

    MEmailMessage* fsMessage = mailbox->CreateDraftMessageL();

    CleanupReleasePushL(*fsMessage);

    switch (message.priority()) {

        case QMessage::HighPriority:

            fsMessage->SetFlag(EmailInterface::EFlag_Important);

            fsMessage->ResetFlag(EmailInterface::EFlag_Low);

            break;

        case QMessage::NormalPriority:

            fsMessage->ResetFlag(EmailInterface::EFlag_Important);

            fsMessage->ResetFlag(EmailInterface::EFlag_Low);

            break;

        case QMessage::LowPriority:

            fsMessage->SetFlag(EmailInterface::EFlag_Low);

            fsMessage->ResetFlag(EmailInterface::EFlag_Important);

            break;            

        }

        if (message.status() & QMessage::Read) {

            fsMessage->SetFlag(EmailInterface::EFlag_Read);

        } else {

            fsMessage->ResetFlag(EmailInterface::EFlag_Read);

        }

    MEmailAddress* sender = mailbox->AddressL();

    sender->SetRole(MEmailAddress::ESender);

    fsMessage->SetReplyToAddressL(*sender);

    QList<QMessageAddress> toList(message.to());

    if (toList.count() > 0) {

        TPtrC16 receiver(KNullDesC);

        QString qreceiver;

        REmailAddressArray toAddress;

        for (int i = 0; i < toList.size(); ++i) {

            qreceiver = toList.at(i).addressee();

            receiver.Set(reinterpret_cast<const TUint16*>(qreceiver.utf16()));

            MEmailAddress* address = mailbox->AddressL();

            address->SetAddressL(receiver);

            address->SetDisplayNameL(receiver);

            address->SetRole(MEmailAddress::ETo);

            toAddress.Append(address);

        }

        fsMessage->SetRecipientsL(MEmailAddress::ETo, toAddress);

    }

    QList<QMessageAddress> ccList(message.cc());

    if (ccList.count() > 0) {

        TPtrC16 receiver(KNullDesC);

        QString qreceiver;

        REmailAddressArray ccAddress;

        for (int i = 0; i < ccList.size(); ++i) {

            qreceiver = ccList.at(i).addressee();

            receiver.Set(reinterpret_cast<const TUint16*>(qreceiver.utf16()));

            MEmailAddress* address = mailbox->AddressL();

            address->SetDisplayNameL(receiver);

            address->SetRole(MEmailAddress::ECc);

            address->SetAddressL(receiver);

            ccAddress.Append(address);

        }

        fsMessage->SetRecipientsL(MEmailAddress::ECc, ccAddress);

    }

    QList<QMessageAddress> bccList(message.bcc());

    if (bccList.count() > 0) {

        TPtrC16 receiver(KNullDesC);

        QString qreceiver;

        REmailAddressArray bccAddress;

        for (int i = 0; i < bccList.size(); ++i) {

            qreceiver = bccList.at(i).addressee();

            receiver.Set(reinterpret_cast<const TUint16*>(qreceiver.utf16()));

            MEmailAddress* address = mailbox->AddressL();

            address->SetDisplayNameL(receiver);

            address->SetRole(MEmailAddress::EBcc);

            address->SetAddressL(receiver);

            bccAddress.Append(address);

        }

        fsMessage->SetRecipientsL(MEmailAddress::EBcc, bccAddress);

    }

    if (message.bodyId() == QMessageContentContainerPrivate::bodyContentId()) {

        // Message contains only body (not attachments)

        QString messageBody = message.textContent();

        if (!messageBody.isEmpty()) {

            QByteArray type = message.contentType();

            QByteArray subType = message.contentSubType();

            MEmailMessageContent* content = fsMessage->ContentL();

            MEmailTextContent* textContent = content->AsTextContentOrNull();

            if (textContent) {

                if (type == "text" && subType == "plain") {

                    textContent->SetTextL(MEmailTextContent::EPlainText, TPtrC(reinterpret_cast<const TUint16*>(message.textContent().utf16())));

                } 

               else if (type == "text" && subType == "html") {

                    textContent->SetTextL(MEmailTextContent::EHtmlText, TPtrC(reinterpret_cast<const TUint16*>(message.textContent().utf16())));

                }

            }

            else

                fsMessage->SetPlainTextBodyL(TPtrC(reinterpret_cast<const TUint16*>(message.textContent().utf16())));

        }

    } else {