/*

* Copyright (c) 2009 - 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "nmframeworkadapterheaders.h"

/*!

    \class NmFrameworkAdapter

    \brief The NmFrameworkAdapter works as an adapter between emailframework which is (legacy)

    Symbian code and emailuis which is done using QT.

    The NmFrameworkAdapter works as an adapter between emailframework which is (legacy)

    Symbian code and emailuis which is done using QT. Most functions in the adapter merely do d

    ata type conversions and forward function calls to emailframework implementation.

    Also events coming from emailframework are converted and emitted as signals.

 */

static const int NmListMessagesBlock = 100;

/*!

    Constructor

*/

NmFrameworkAdapter::NmFrameworkAdapter()

: mFSfw(NULL),

  mSearchObserver(NULL),

  mCurrentMailBox(NULL),

  mStateExtension(NULL)

{

    NM_FUNCTION;

    // get s60 email framework

    TRAP_IGNORE(mFSfw = CFSMailClient::NewL());

    if (mFSfw) {

        TRAP_IGNORE(mFSfw->AddObserverL(*this));

    }

}

/*!

    Destructor

*/

NmFrameworkAdapter::~NmFrameworkAdapter()

{

    NM_FUNCTION;

    delete mCurrentMailBox;

    mCurrentMailBox = NULL;

    if (mSearchObserver) {

        delete mSearchObserver;

        mSearchObserver = NULL;

    }

    if (mFSfw) {

        mFSfw->RemoveObserver(*this);

        mFSfw->Close();

    }

    mFSfw = NULL;

}

/*!

    Add ids of all existing mailboxes to list given as reference.

    \param mailboxIdList The list to receive the mailbox ids.

    \return Error code.

 */

int NmFrameworkAdapter::listMailboxIds(QList<NmId>& mailboxIdList)

{

    NM_FUNCTION;

    QList<NmMailbox*> mailboxList;

    int ret = listMailboxes(mailboxList);

    if (ret == NmNoError) {

        QListIterator<NmMailbox*> iterator(mailboxList);

        while (iterator.hasNext()) {

            NmMailbox *box = iterator.next();

            mailboxIdList.append(box->id());

            delete box;

            box = NULL;

        }

    }

    return ret;

}

/*!

    Fill array given as reference with new mailbox objects, one for each existing mailbox.

    \param mailboxList The list to receive the mailbox object pointers, ownership of which is transferred to caller.

    \return Error code.

 */

int NmFrameworkAdapter::listMailboxes(QList<NmMailbox*>& mailboxList)

{

    NM_FUNCTION;

    // get list of mailboxes from all plugins

    TFSMailMsgId id;

    id.SetNullId();

    RPointerArray<CFSMailBox> mailBoxes;

    //if id.IsNullId(), mailboxes are listed from all plugins.

    //otherwise, only from the given one.

    TInt rcode = mFSfw->ListMailBoxes(id, mailBoxes);

    if (rcode == NmNoError) {

        // convert mailbox data to QT classes

        NmMailbox *box(NULL);

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

            box = NULL;

            if (mailBoxes[i]) {

                box = mailBoxes[i]->GetNmMailbox();

                }

            if (box) {

                mailboxList.append(box);

                }

            }

        }

    mailBoxes.ResetAndDestroy();

    return rcode;

}

/*!

    Get a pointer to a new mailbox object for the mailbox identified by id.

    \param id Id of the mailbox.

    \param mailbox Pointer reference to receive the mailbox object, ownership of which is transferred to caller.

    \return Error code.

 */

int NmFrameworkAdapter::getMailboxById(const NmId& id, NmMailbox*& mailbox)

{

    NM_FUNCTION;

    const TFSMailMsgId mailMsgId(id.pluginId32(), id.id32());

    CFSMailBox *box(NULL);

    TRAPD(err, box = mFSfw->GetMailBoxByUidL(mailMsgId));

    if (err == KErrNone && box) {

        mailbox = box->GetNmMailbox();

        delete box;

        box = NULL;

    }

    return err;

}

/*!

    Deletes the mailbox with the given id asynchronously.

    \param mailboxId Id of the mailbox to be deleted.

    \return Error code.

 */

QPointer<NmOperation> NmFrameworkAdapter::deleteMailboxById(const NmId& mailboxId)

{

    NM_FUNCTION;

    QPointer<NmOperation> oper = new NmFwaDeleteMailboxOperation(mailboxId, *mFSfw);

    return oper;

}

/*!

    Returns folder

    \param mailboxId Id of the mailbox containing the folder.

    \param folderId Id of the requested folder

    \param message Pointer reference to receive a folder object, ownership is transferred.

    \return Error code.

 */

int NmFrameworkAdapter::getFolderById(const NmId& mailboxId, const NmId& folderId, NmFolder*& folder)

{

    NM_FUNCTION;

    TRAPD(err, getFolderByIdL(mailboxId, folderId, folder));

    return err;

}

/*!

    Leaving version of getFolderById function

 */

void NmFrameworkAdapter::getFolderByIdL(const NmId& mailboxId, const NmId& folderId, NmFolder*& folder)

{

    NM_FUNCTION;

    CFSMailFolder* fsFolder(NULL);

    fsFolder = mFSfw->GetFolderByUidL(TFSMailMsgId(mailboxId), TFSMailMsgId(folderId));

    if (fsFolder) {

        folder = fsFolder->GetNmFolder();

        delete fsFolder;

        fsFolder = NULL;

    } else {

        User::Leave(KErrNotFound);

    }

}

/*!

    Returns message from the store together with whole message part structure

    \param mailboxId Id of the mailbox containing the folder.

    \param folderId Id of the folder containing the message.

    \param messageId Id of the message.

    \param message Pointer reference to receive a message object containing requested message,

     ownership is transferred.

    \return Error code.

 */

int NmFrameworkAdapter::getMessageById(

    const NmId& mailboxId,

    const NmId& folderId,

    const NmId& messageId,

    NmMessage*& message)

{

    NM_FUNCTION;

    TRAPD(err, getMessageByIdL(mailboxId, folderId, messageId, message));

    return err;

}

/*!

    Leaving version of getMessageById function

 */

void NmFrameworkAdapter::getMessageByIdL(

    const NmId& mailboxId,

    const NmId& folderId,

    const NmId& messageId,

    NmMessage*& message)

{

    NM_FUNCTION;

    // select message details to be listed

    TFSMailDetails details(EFSMsgDataStructure);

    CFSMailMessage* newMessage(NULL);

    newMessage = mFSfw->GetMessageByUidL(TFSMailMsgId(mailboxId), TFSMailMsgId(folderId),

        TFSMailMsgId(messageId), details);

    // GetMessageByUidL can return NULL pointer

    if (newMessage) {

        message = newMessage->GetNmMessage();

        //assign all children found by mail plugin to NmMessage

        message->removeAllChildParts();

        childrenToNmMessagePartL(newMessage, message);

        delete newMessage;

        newMessage = NULL;

    }

    else {

        User::Leave(KErrNotFound);

    }

}

/*!

    Returns list of folders in a mailbox.

  \param mailboxId Id of the mailbox containing the folder.

  \param folderList Reference to a pointer list to receive pointers to the folders.

  \return Error code.

 */

int NmFrameworkAdapter::listFolders(

    const NmId& mailboxId,

    QList<NmFolder*>& folderList)

{

    NM_FUNCTION;

    int err(NmNoError);

    TRAP(err, currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId));

    if (KErrNone == err && currentMailbox) {

        RPointerArray<CFSMailFolder> folders = currentMailbox->ListFolders();

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

            folderList.append(folders[i]->GetNmFolder());

        }

        delete currentMailbox;

        currentMailbox = NULL;

    } else {

        err = NmNotFoundError;

    }

    return err;

}

/*!

    Fetches all the messages from the given folder and appends their meta data

    into the given list.

    \param folder The folder instance.

    \param messageEnvelopeList The list where the data is stored to.

    \param maxEnvelopeCount The maximum number of messages to get.

*/

void NmFrameworkAdapter::getMessagesFromFolderL(

     CFSMailFolder *folder,

     QList<NmMessageEnvelope*> &messageEnvelopeList,

     const int maxEnvelopeCount)

{

    NM_FUNCTION;

    // validity of input parameters is checked in calling function

    int blockSize = NmListMessagesBlock;

    int maxItemCount = NmMaxItemsInMessageList;

    if (maxEnvelopeCount < NmMaxItemsInMessageList) {

        maxItemCount = maxEnvelopeCount;

        if(maxEnvelopeCount < NmListMessagesBlock) {

            blockSize = maxEnvelopeCount;

        }

    }

    // First prepare all the parameters and select message details to be listed.

    TFSMailDetails details(EFSMsgDataEnvelope);

    // Set the sorting criteria.

    TFSMailSortCriteria criteria;

    criteria.iField = EFSMailSortByDate;

    criteria.iOrder = EFSMailDescending;

    RArray<TFSMailSortCriteria> sorting;

    CleanupClosePushL(sorting);

    sorting.Append(criteria);

    // Get the message list from the backend.

    MFSMailIterator* iterator(NULL);

    iterator = folder->ListMessagesL(details, sorting);

    if (iterator) {

        CleanupStack::PushL(iterator);

        RPointerArray<CFSMailMessage> messages;

        CleanupResetAndDestroy<CFSMailMessage>::PushL(messages);

        // The message list is fetched in blocks to prevent OOM in protocol

        // plugin side.

        bool moreMessagesToFollow(false);

        moreMessagesToFollow = iterator->NextL(TFSMailMsgId(), blockSize, messages);

        for (int i = blockSize;

             i < maxItemCount && moreMessagesToFollow;

             i += blockSize) {

            moreMessagesToFollow =

                iterator->NextL(messages[i-1]->GetMessageId(), blockSize, messages);

        }

        // Add all the found emails into the result list.

        const TInt messageCount(messages.Count());

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

            NmMessageEnvelope *newEnvelope(NULL);

            newEnvelope = messages[i]->GetNmMessageEnvelope();

            if (newEnvelope) {

                messageEnvelopeList.append(newEnvelope);

            }

        }

        CleanupStack::PopAndDestroy(&messages);

        CleanupStack::Pop(iterator);

        delete iterator;

        iterator = NULL;

    }

    CleanupStack::PopAndDestroy(); // sorting

}

/*!

    Returns list of envelopes from the backend for specific mailbox and folder.

    \param mailboxId Id of the mailbox containing the folder.

    \param folderId Folder id.

    \param messageMetaDataList Reference to pointer list to receive the envelope objects,

     ownership is transferred.

    \return Error code.

 */

int NmFrameworkAdapter::listMessages(

	const NmId &mailboxId,

    const NmId &folderId,

    QList<NmMessageEnvelope*> &messageEnvelopeList)

{

    NM_FUNCTION;

    TRAPD(err, listMessagesL(mailboxId,folderId,messageEnvelopeList, NmMaxItemsInMessageList));

    return err;

}

/*!

    Fetches the meta data for each message in the given mailbox and given

    folder.

    \param mailboxId The ID of the mailbox of which messages to list.

    \param folderId The ID of the folder of which messages to list.

    \param messageEnvelopeList The list where the message data is stored to.

                               Note that the ownership is transferred!

    \param maxAmountOfEnvelopes The maximum number of messages to list.

    \return If success, KErrNone, an error code otherwise.

*/

int NmFrameworkAdapter::listMessages(

        const NmId& mailboxId,

        const NmId& folderId,

        QList<NmMessageEnvelope*> &messageEnvelopeList,

        const int maxAmountOfEnvelopes)

{

    NM_FUNCTION;

    TInt err(KErrNone);

    TRAP(err, listMessagesL(mailboxId,folderId, messageEnvelopeList,maxAmountOfEnvelopes) );

    return err;

}

/*!

    Fetches the meta data for each message in the given mailbox and given

    folder. Note that this private method can leave.

*/

void NmFrameworkAdapter::listMessagesL(

        const NmId &mailboxId,

        const NmId &folderId,

        QList<NmMessageEnvelope*> &messageEnvelopeList,

        const int maxAmountOfEnvelopes)

{

    NM_FUNCTION;

    // If we are requesting 0 or less mails, we can just return.

    if (maxAmountOfEnvelopes <= 0) {

        return;

    }

    CFSMailBox *mailbox(NULL);

    mailbox = mFSfw->GetMailBoxByUidL(mailboxId);

    if (!mailbox) {

        User::Leave(KErrNotFound);

    }

    CleanupStack::PushL(mailbox);

    CFSMailFolder* folder(NULL);

    folder = mFSfw->GetFolderByUidL(mailbox->GetId(), TFSMailMsgId(folderId));

    if (folder) {

        CleanupStack::PushL(folder);

        getMessagesFromFolderL(folder, messageEnvelopeList, maxAmountOfEnvelopes);

        CleanupStack::PopAndDestroy(folder);

    }

    CleanupStack::PopAndDestroy(mailbox);

}

/*!

    Returns list of messages from the backend for specific mailbox and folder.

    \param mailboxId Id of the mailbox containing the folder.

    \param folderId Folder id.

    \param messageMetaDataList Reference to pointer list to receive the envelope objects,

     ownership is transferred.

    \return Error code.

 */

int NmFrameworkAdapter::listMessages(

    const NmId &mailboxId,

    const NmId &folderId,

    QList<NmMessage*> &messageList,

    const int maxAmountOfMessages)

{

    NM_FUNCTION;

    TRAPD(err, listMessagesL(mailboxId,folderId,messageList, maxAmountOfMessages));

    return err;

}

/*!

    Leaving version of list messages with NmMessageList input

 */

void NmFrameworkAdapter::listMessagesL(

        const NmId &mailboxId,

        const NmId &folderId,