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

**

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

#include "qmtmengine_symbian_p.h"

#include "qmessage_symbian_p.h"

#include "qmessagesortorder_p.h"

#include "qmessageaccount.h"

#include "qmessageaccount_p.h"

#include "qmessageaccountfilter.h"

#include "qmessageaccountfilter_p.h"

#include "qmessageaccountsortorder_p.h"

#include "qmessagefoldersortorder_p.h"

#include "qmessagesortorder_p.h"

#include "qmessagefolder.h"

#include "qmessagefolder_p.h"

#include "qmessagefolderfilter.h"

#include "qmessagefolderfilter_p.h"

#include "qmessageservice_symbian_p.h"

#include "qmessagecontentcontainer_symbian_p.h"

#include "qmessagecontentcontainer_p.h"

#include <msvstd.h>

#include <msvids.h> // TMsvId's

#include <mtclreg.h>   // CClientMtmRegistry

#include <smsclnt.h>   // CSmsClientMtm

#include <mmsclient.h> // CMmsClientMtm

#include <smtcmtm.h>   // CSmtpClientMtm

#include <impcmtm.h>   // CImap4ClientMtm

#include <popcmtm.h>   // CPop3ClientMtm

#include <cemailaccounts.h> //CEmailAccounts

#include <msvfind.h>   // CMsvFindOperation  

#include <mtmdef.h>    // TMsvPartList

#include <utf.h>       // CnvUtfConverter

#include <eikenv.h>

#include <smut.h>

#include <smuthdr.h>

#include <mtuireg.h> // CMtmUiRegistry

#include <mtmuibas.h> // CBaseMtmUi

#include <rsendas.h>

#include <rsendasmessage.h>

#include <cmsvrecipientlist.h>

#include <imapset.h>

#include <charconv.h>

#include <imcvtext.h> // KImcvMultipart declaration

#include <QTextCodec>

QTM_BEGIN_NAMESPACE

const TInt KWaitAfterReceivedMessage = 100000; // = 0.1 seconds

#define KDocumentsEntryIdValue    0x1008

Q_GLOBAL_STATIC(CMTMEngine,mtmEngine);

CMTMEngine::CMTMEngine()

 : CActive(EPriorityStandard)

{

    iFsSession.Connect();

    CActiveScheduler::Add(this);

    iTimer.CreateLocal();

    TRAPD(err, 

        ipMsvSession = CMsvSession::OpenSyncL(*this);

        iSessionReady = ETrue;

        ipClientMtmReg = CClientMtmRegistry::NewL(*ipMsvSession);

        ipSmsMtm = static_cast<CSmsClientMtm*>(ipClientMtmReg->NewMtmL(KUidMsgTypeSMS));

        ipMmsMtm = static_cast<CMmsClientMtm*>(ipClientMtmReg->NewMtmL(KUidMsgTypeMultimedia));

        ipSmtpMtm = static_cast<CSmtpClientMtm*>(ipClientMtmReg->NewMtmL(KUidMsgTypeSMTP));

        ipImap4Mtm = static_cast<CImap4ClientMtm*>(ipClientMtmReg->NewMtmL(KUidMsgTypeIMAP4));

        ipPop3Mtm = static_cast<CPop3ClientMtm*>(ipClientMtmReg->NewMtmL(KUidMsgTypePOP3));

        );

    Q_UNUSED(err)

    // Create & Add SMS Account

    TRAPD(accountError,

        iSMSAccountidAsString = QString::number(mtmServiceEntryIdL(CMTMEngine::MTMTypeSMS));

        QMessageAccount smsAcc = QMessageAccountPrivate::from(QMessageAccountId(iSMSAccountidAsString),

                                                              QString("SMS"),

                                                              mtmServiceEntryIdL(CMTMEngine::MTMTypeSMS),

                                                              0,

                                                              QMessage::Sms);

        iAccounts.insert(iSMSAccountidAsString, smsAcc);

        // Create & Add MMS Account

        iMMSAccountidAsString = QString::number(mtmServiceEntryIdL(CMTMEngine::MTMTypeMMS));

        QMessageAccount mmsAcc = QMessageAccountPrivate::from(QMessageAccountId(iMMSAccountidAsString),

                                                              QString("MMS"),

                                                              mtmServiceEntryIdL(CMTMEngine::MTMTypeMMS),

                                                              0,

                                                              QMessage::Mms | QMessage::Email);

        iAccounts.insert(iMMSAccountidAsString, mmsAcc);

        updateEmailAccountsL();

        );

    Q_UNUSED(accountError)

    TRAPD(err2,

        TBuf<KMaxPath> privatePath;

        FsSession().CreatePrivatePath(EDriveC);

        FsSession().PrivatePath(privatePath);

        iPath.Append(_L("c:"));

        iPath.Append(privatePath);

        iPath.Append(_L("tempattachments\\"));                         

        CFileMan* pFileMan = CFileMan::NewL(FsSession());

        CleanupStack::PushL(pFileMan);

        pFileMan->RmDir(iPath);

        FsSession().MkDirAll(iPath);

        CleanupStack::PopAndDestroy(pFileMan);

    );

    Q_UNUSED(err2)

}

CMTMEngine::~CMTMEngine()

{

    iCmsvEntryPoolFree.ResetAndDestroy();

    iCmsvEntryPoolInUse.ResetAndDestroy();

    delete ipPop3Mtm;

    delete ipImap4Mtm;

    delete ipSmtpMtm;

    delete ipMmsMtm;

    delete ipSmsMtm;

    delete ipClientMtmReg;

    delete ipMsvSession;

    TRAPD(error,

        TBuf<KMaxPath> privatePath;

        FsSession().CreatePrivatePath(EDriveC);

        FsSession().PrivatePath(privatePath);

        TBuf<KMaxPath> path;

        path.Append(_L("c:"));

        path.Append(privatePath);

        path.Append(_L("tempattachments\\"));                         

        CFileMan* pFileMan=CFileMan::NewL(FsSession());

        CleanupStack::PushL(pFileMan);

        pFileMan->RmDir(path);

        CleanupStack::PopAndDestroy(pFileMan);

        );

    Q_UNUSED(error)

    Cancel();

    iTimer.Close();

    iFsSession.Close();

}

CMTMEngine* CMTMEngine::instance()

{

    return mtmEngine();

}

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

{

    CMTMEngine* pMTMEngine = mtmEngine();

    return QMessageAccountSortOrderPrivate::lessThan(pMTMEngine->iCurrentAccountOrdering,

                                                    pMTMEngine->account(accountId1),

                                                    pMTMEngine->account(accountId2));

}

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

{

    iCurrentAccountOrdering = sortOrder;

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

}

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

{

    CMTMEngine* pMTMEngine = mtmEngine();

    return QMessageFolderSortOrderPrivate::lessThan(pMTMEngine->iCurrentFolderOrdering,

                                                   pMTMEngine->folder(folderId1),

                                                   pMTMEngine->folder(folderId2));

}

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

{

    iCurrentFolderOrdering = sortOrder;

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

}

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

{

    CMTMEngine* pMTMEngine = mtmEngine();

    return QMessageSortOrderPrivate::lessThan(pMTMEngine->iCurrentMessageOrdering, message1, message2);

}

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

{

    iCurrentMessageOrdering = sortOrder;

    QList<QMessage> messages;

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

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

    }

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

    messageIds.clear();

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

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

    }

}

QMessageAccountIdList CMTMEngine::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, iAccounts) {

                accountIds.append(value.id());

            }

        }

    } else {

        if (privateMessageAccountFilter->_valid) {

            foreach (QMessageAccount value, iAccounts) {

                if (privateMessageAccountFilter->filter(value)) {

                    accountIds.append(value.id());

                }

            }

        } else {

            foreach (QMessageAccount value, iAccounts) {

                if (privateMessageAccountFilter->filter(value)) {

                    accountIds.append(value.id());

                }

            }

        }

    }

    if (!sortOrder.isEmpty()) {

        orderAccounts(accountIds, sortOrder);

    }

    applyOffsetAndLimitToAccountIds(accountIds, offset, limit);

    return accountIds;

}

void CMTMEngine::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 CMTMEngine::countAccounts(const QMessageAccountFilter &filter) const

{

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

}

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

{

    TRAPD(err, updateEmailAccountsL());

    Q_UNUSED(err)

    return iAccounts[id.toString()];

}

QMessageAccountId CMTMEngine::accountIdByServiceId(TMsvId serviceId) const

{

    TRAPD(err, updateEmailAccountsL());

    Q_UNUSED(err)

    foreach (QMessageAccount value, iAccounts) {

        if (value.d_ptr->_service1EntryId == serviceId ||

            value.d_ptr->_service2EntryId == serviceId) {

            return value.id();

        }

    }

    return QMessageAccountId();

}

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

{

    TRAPD(err, updateEmailAccountsL());

    Q_UNUSED(err)

    if (type == QMessage::Email) {

        // Email

        return idefaultEmailAccountId;

    } else {

        // Sms & Mms

        foreach (QMessageAccount value, iAccounts) {

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

                return value.id();

            }

        }

    }

    return QMessageAccountId();

}

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

{

    QMessageAccountIdList accountIds;

    foreach (QMessageAccount value, iAccounts) {

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

            accountIds.append(value.id());

        }

    }

    return accountIds;

}

void CMTMEngine::updateEmailAccountsL() const

{

    QStringList keys = iAccounts.keys();

    keys.removeOne(iSMSAccountidAsString);

    keys.removeOne(iMMSAccountidAsString);

    CEmailAccounts* pEmailAccounts = CEmailAccounts::NewLC();

    // Default Email account will be the first Email account in the iAccounts list

    TSmtpAccount defaultAccount;

    TInt err = pEmailAccounts->DefaultSmtpAccountL(defaultAccount);    

    if (err == KErrNone) {

        QString idAsString;

        if (defaultAccount.iRelatedService != 0) {

            idAsString = QString::number(defaultAccount.iRelatedService);

        } else {

            idAsString = QString::number(defaultAccount.iSmtpService);

        }

        if (!iAccounts.contains(idAsString)) {

            QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(idAsString),

                                                                   QString::fromUtf16(defaultAccount.iSmtpAccountName.Ptr(), defaultAccount.iSmtpAccountName.Length()),

                                                                   defaultAccount.iRelatedService,

                                                                   defaultAccount.iSmtpService,

                                                                   QMessage::Email);

            iAccounts.insert(idAsString, account);

            idefaultEmailAccountId = account.id();

        } else {

            keys.removeOne(idAsString);

        }

    } else {

        idefaultEmailAccountId = QMessageAccountId();

    }

    RArray<TImapAccount> imapAccounts(10);

    pEmailAccounts->GetImapAccountsL(imapAccounts);

    CleanupClosePushL(imapAccounts);

    for (int i=0; i < imapAccounts.Count(); i++) {

        QString idAsString = QString::number(imapAccounts[i].iImapService);

        if (!iAccounts.contains(idAsString)) {

            QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(idAsString),

                                                                   QString::fromUtf16(imapAccounts[i].iImapAccountName.Ptr(), imapAccounts[i].iImapAccountName.Length()),

                                                                   imapAccounts[i].iImapService,

                                                                   imapAccounts[i].iSmtpService,

                                                                   QMessage::Email);

            iAccounts.insert(idAsString, account);

        } else {

            keys.removeOne(idAsString);

        }

    }

    CleanupStack::PopAndDestroy(&imapAccounts);

    RArray<TPopAccount> popAccounts(10);

    pEmailAccounts->GetPopAccountsL(popAccounts);

    CleanupClosePushL(popAccounts);

    for (int i=0; i < popAccounts.Count(); i++) {

        QString idAsString = QString::number(popAccounts[i].iPopService);

        if (!iAccounts.contains(idAsString)) {

            QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(QString::number(popAccounts[i].iPopService)),

                                                                   QString::fromUtf16(popAccounts[i].iPopAccountName.Ptr(), popAccounts[i].iPopAccountName.Length()),

                                                                   popAccounts[i].iPopService,

                                                                   popAccounts[i].iSmtpService,

                                                                   QMessage::Email);

            iAccounts.insert(idAsString, account);

        } else {

            keys.removeOne(idAsString);

        }

    }

    CleanupStack::PopAndDestroy(&popAccounts);

    RArray<TSmtpAccount> smtpAccounts(10);

    pEmailAccounts->GetSmtpAccountsL(smtpAccounts);

    CleanupClosePushL(smtpAccounts);

    for (int i=0; i < smtpAccounts.Count(); i++) {

        if (smtpAccounts[i].iRelatedService == 0) {

            QString idAsString = QString::number(smtpAccounts[i].iSmtpService);

            if (!iAccounts.contains(idAsString)) {

                QMessageAccount account = QMessageAccountPrivate::from(QMessageAccountId(QString::number(smtpAccounts[i].iSmtpService)),

                                                                       QString::fromUtf16(smtpAccounts[i].iSmtpAccountName.Ptr(), smtpAccounts[i].iSmtpAccountName.Length()),

                                                                       smtpAccounts[i].iRelatedService,

                                                                       smtpAccounts[i].iSmtpService,

                                                                       QMessage::Email);

                iAccounts.insert(idAsString, account);

            } else {

                keys.removeOne(idAsString);

            }

        }

    }

    CleanupStack::PopAndDestroy(&smtpAccounts);

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

        iAccounts.remove(keys[i]);

    }

    CleanupStack::PopAndDestroy(pEmailAccounts);

}

TUid CMTMEngine::mtmUidByType(MTMType aMTMType)

{

    switch(aMTMType) {

    case CMTMEngine::MTMTypeSMS:  return KUidMsgTypeSMS;

    case CMTMEngine::MTMTypeMMS:  return KUidMsgTypeMultimedia;

    case CMTMEngine::MTMTypeSMTP: return KUidMsgTypeSMTP;

    case CMTMEngine::MTMTypeIMAP: return KUidMsgTypeIMAP4;

    case CMTMEngine::MTMTypePOP3: return KUidMsgTypePOP3;

    }

    return TUid();

}

CBaseMtm* CMTMEngine::mtmByUid(TUid aMTMUid)

{

    if (aMTMUid == KUidMsgTypeSMS) {

        return ipSmsMtm;

    } else if (aMTMUid == KUidMsgTypeMultimedia) {

        return ipMmsMtm;

    } else if (aMTMUid == KUidMsgTypeSMTP) {

        return ipSmtpMtm;

    } else if (aMTMUid == KUidMsgTypeIMAP4) {

        return ipImap4Mtm;

    } else if (aMTMUid == KUidMsgTypePOP3) {

        return ipPop3Mtm;

    }

    return 0;

}

TMsvId CMTMEngine::mtmServiceEntryIdL(MTMType aMTMType) const

{

    TUid mtmUID;

    switch(aMTMType) {

    case CMTMEngine::MTMTypeSMS:

        mtmUID = KUidMsgTypeSMS;

        break;

    case CMTMEngine::MTMTypeMMS:

        mtmUID = KUidMsgTypeMultimedia;

        break;

    case CMTMEngine::MTMTypeSMTP:

        mtmUID = KUidMsgTypeSMTP;

        break;

    case CMTMEngine::MTMTypeIMAP:

        mtmUID = KUidMsgTypeIMAP4;

        break;

    case CMTMEngine::MTMTypePOP3:

        mtmUID = KUidMsgTypePOP3;

        break;

    }

    CMsvEntry* pCurrentEntry = ipMsvSession->GetEntryL(KMsvRootIndexEntryId);

    CleanupStack::PushL(pCurrentEntry);

    // Sorting or grouping is not needed

    pCurrentEntry->SetSortTypeL(TMsvSelectionOrdering(KMsvNoGrouping,EMsvSortByNone, ETrue));

    // Loop through child entries until MTM specific

    // root entry has been found 

    TMsvId mtmRootEntryId = KMsvRootIndexEntryId;

    TInt count = pCurrentEntry->Count();

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

        const TMsvEntry& child = (*pCurrentEntry)[i];

        if (child.iMtm == mtmUID) {

            mtmRootEntryId = child.Id();

            break;

        }

    }