/*

* Copyright (c) 2009 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;

static const int nmMaxItemsInMessageList = 1000;

/*!

    Constructor

*/

NmFrameworkAdapter::NmFrameworkAdapter( ) : mFSfw(NULL)

{

    NMLOG("NmFrameworkAdapter::NmFrameworkAdapter() <---");

    // get s60email framework

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

    if(mFSfw){

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

        }

    NMLOG("NmFrameworkAdapter::NmFrameworkAdapter() --->");

}

/*!

    Destructor

*/

NmFrameworkAdapter::~NmFrameworkAdapter()

{

    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)

{

    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)

{

    // 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(0);

        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)

{

    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;

}

/*!

    Delete the mailbox with the given id. Not implemented yet.

    \param id Id of the mailbox to be deleted.

    \return Error code.

 */

int NmFrameworkAdapter::deleteMailboxById(const NmId& /*id*/)

{

    return 0;

}

/*!

    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)

{

    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)

{

    // 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);

    }

    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)

{

    CFSMailBox* currentMailbox = NULL;

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

    if (KErrNone == err) {

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

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

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

        }

        return KErrNone;

    }

    else {

        return err;

    }

}

/*!

    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)

{

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

    return err;

}

/*!

    Leaving version of list messages

 */

void NmFrameworkAdapter::listMessagesL(

        const NmId &mailboxId,

        const NmId &folderId,

        QList<NmMessageEnvelope*> &messageEnvelopeList)

{

    CFSMailBox * currentMailbox(NULL);

    CFSMailFolder* folder(NULL);

    currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId);

    if (!currentMailbox) {

        User::Leave(KErrNotFound);

    }

    CleanupStack::PushL(currentMailbox);

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

    if (folder) {

        CleanupStack::PushL(folder);

        // First prepare all the parameters

        // select message details to be listed

        TFSMailDetails details(EFSMsgDataEnvelope);

        // set sorting criteria

        TFSMailSortCriteria criteria;

        criteria.iField = EFSMailSortByDate;

        criteria.iOrder = EFSMailDescending;

        RArray<TFSMailSortCriteria> sorting;

        CleanupClosePushL(sorting);

        sorting.Append(criteria);

        TFSMailMsgId currentMessageId; // first call contains NULL id as begin id

        // get messages list from the backend

        MFSMailIterator* iterator(NULL);

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

        if (iterator) {

            CleanupStack::PushL(iterator);

            RPointerArray<CFSMailMessage> messages;

            CleanupResetAndDestroy<CFSMailMessage>::PushL(messages);

            //Message list is fetched in blocks to prevent OOM in protocol plugin side

            bool moreMessagesToFollow(false);

            moreMessagesToFollow = iterator->NextL(

                TFSMailMsgId(), nmListMessagesBlock, messages);

            for ( int i = nmListMessagesBlock;

                  i < nmMaxItemsInMessageList && moreMessagesToFollow ;

                  i += nmListMessagesBlock ) {

                moreMessagesToFollow = iterator->NextL(

                    messages[i-1]->GetMessageId(), nmListMessagesBlock, messages);

            }

            //Add all found emails to the result list

            for(TInt i=0; i<messages.Count(); 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

        CleanupStack::PopAndDestroy(folder);

    }

    CleanupStack::PopAndDestroy(currentMailbox);

}

/*!

    Starts a message fetching operation.

    \param mailboxId Id of the mailbox containing the folder.

    \param folderId Id of the folder containing the message.

    \param messageId Id of the message to fetch.

    \return An NmOperation object for the operation, ownership is transferred to caller

 */

NmOperation *NmFrameworkAdapter::fetchMessage(

    const NmId &mailboxId,

    const NmId &folderId,

    const NmId &messageId )

{

    NmOperation *oper = new NmFwaMessageFetchingOperation(mailboxId, folderId, messageId, *mFSfw);

    return oper;

}

/*!

    Starts a message part fetching operation.

    \param mailboxId Id of the mailbox containing the folder.

    \param folderId Id of the folder containing the message.

    \param messageId Id of message containing the message parts

    \param messagePartIds array of ids to be fetched

    \return An NmOperation object for the operation, ownership is transferred to caller

 */

NmOperation *NmFrameworkAdapter::fetchMessagePart( 

    const NmId &mailboxId,

    const NmId &folderId,

    const NmId &messageId,

    const NmId &messagePartId)

{

    NmOperation *oper = new NmFwaMessagePartFetchingOperation(

            mailboxId, folderId, messageId, messagePartId, *mFSfw);

    return oper;

}

/*!

    Get the id of a standard folder.

    \param mailboxId Id of the mailbox containing the folder.

    \param folderType Type of standard folder to get the id of.

    \return Id of the standard folder, or NmId for which NmId.getId() == 0 if not found.

 */

NmId NmFrameworkAdapter::getStandardFolderId(

    const NmId& mailboxId,

    NmFolderType folderType )

{

    TFSMailMsgId folderId;

    NmId resultId(0);

    CFSMailBox * currentMailbox(NULL);

    TRAPD(error, currentMailbox = mFSfw->GetMailBoxByUidL(mailboxId) );

    if( !currentMailbox || error != KErrNone ) {

    	return resultId;

    }

    switch(folderType) {

    	case NmFolderInbox:

    		folderId = currentMailbox->GetStandardFolderId( EFSInbox );

    		break;

    	case NmFolderOutbox:

    		folderId = currentMailbox->GetStandardFolderId( EFSOutbox );

    		break;

    	case NmFolderDrafts:

    		folderId = currentMailbox->GetStandardFolderId( EFSDraftsFolder );

    		break;

    	case NmFolderSent:

    		folderId = currentMailbox->GetStandardFolderId( EFSSentFolder );

    		break;

    	case NmFolderDeleted:

    		folderId = currentMailbox->GetStandardFolderId( EFSDeleted );

    		break;

    	case NmFolderOther:

    	default:

    		folderId = currentMailbox->GetStandardFolderId( EFSOther );

    		break;

    }

    delete currentMailbox;

    currentMailbox = NULL;

    resultId.setPluginId32(static_cast<quint32>(folderId.PluginId().iUid));

    resultId.setId32(folderId.Id());

    return resultId;

}

/*!

    Connect to mailbox if not already connected and refresh.

    \param mailboxId Id of the mailbox.

    \return Async request id or error code.

 */

int NmFrameworkAdapter::refreshMailbox(NmId mailboxId)

{

    TRAPD(err, RefreshMailboxL(mailboxId)); // return value not used

    return ( err == KErrNone ) ? NmNoError : NmGeneralError;

}

/*!

    Sets content for the given message part. Client shouldn't create

    message part on its own. Instead it should be requested by calling

    e.g. getMessageById.

    \param mailboxId Id of the mailbox containing the folder (Unused).

    \param folderId Id of the folder containing the message (Unused).

    \param messageId Id of the message (Unused).

    \param messagePart Part of a message for which content is going to be requested.

    \return Error code.

 */

int NmFrameworkAdapter::contentToMessagePart(

    const NmId &mailboxId,

    const NmId &folderId,

    const NmId &messageId,

    NmMessagePart &messagePart)

{

    TRAPD(err, contentToMessagePartL(mailboxId,folderId,messageId,messagePart));

    return err;

}

/*!

    Leaving version of contentToMessagePart function

 */

void NmFrameworkAdapter::contentToMessagePartL(

    const NmId &mailboxId,

    const NmId &folderId,

    const NmId &messageId,

    NmMessagePart &messagePart)

{

    CFSMailMessagePart* cfsPart = CFSMailMessagePart::NewLC(messageId,messagePart);

    cfsPart->SetMailBoxId(TFSMailMsgId(mailboxId));

    cfsPart->SetFolderId(TFSMailMsgId(folderId));

    QString contentType = messagePart.contentType();

    if (cfsPart && contentType.startsWith(NmContentTypeTextPlain)) {

        // add 1 for max size for zero termination and prevend 0 size hbufc

        HBufC* data = HBufC::NewLC(cfsPart->FetchedContentSize()+1);

        TPtr dataPtr = data->Des();

        TInt startOffset = 0;

        cfsPart->GetContentToBufferL(dataPtr, startOffset);

        messagePart.setTextContent(NmConverter::toQString(dataPtr), contentType);

        CleanupStack::PopAndDestroy(data);

    }

    else if (cfsPart){

        RFile file = cfsPart->GetContentFileL();

        TInt fileSize = 0;

        file.Size(fileSize);

        if (fileSize != 0) {

            HBufC8* data = HBufC8::NewLC(fileSize);

            TPtr8 dataPtr = data->Des();

            if (fileSize != 0) {

                TInt dummyPos = 0;

                file.Seek(ESeekStart, dummyPos);

                User::LeaveIfError(file.Read(dataPtr));

            }

            if (contentType.startsWith(NmContentTypeTextHtml) || contentType.contains( NmContentDescrAttachmentHtml )) {

                messagePart.setTextContent( QString::fromUtf8(reinterpret_cast<const char*>(

                        dataPtr.Ptr()), fileSize), contentType);

            }

            else {

                messagePart.setBinaryContent(QByteArray(

                        reinterpret_cast<const char*>(dataPtr.Ptr()), fileSize), contentType);

            }

            CleanupStack::PopAndDestroy(data);

        }

        file.Close();

    }

    else {

        // null cfsPart

        User::Leave(KErrNotFound);

    }

    CleanupStack::PopAndDestroy(cfsPart);

}

/*!

    Deletes the listed messages from specific mailbox and folder.

    \param mailboxId Id of the mailbox containing the folder.

    \param folderId Id of the folder containing the messages.

    \param messageIdList List of ids of the messages to be deleted.

    \return Error code.

 */

int NmFrameworkAdapter::deleteMessages(

	const NmId &mailboxId,

	const NmId &folderId,

	const QList<NmId> &messageIdList)

{

    TInt err = NmNoError;

    RArray<TFSMailMsgId> messageIds;

    for (TInt i=0; i<messageIdList.size(); i++) {

        err = messageIds.Append(TFSMailMsgId(messageIdList[i]));

        if (err!=NmNoError) {

            break;

        }

    }

    if (NmNoError == err) {