/*

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

/*!

    \class NmUiEngine

    \brief NmUiEngine provides a controller-type services for the email UI.

*/

NmUiEngine *NmUiEngine::mInstance;

int NmUiEngine::mReferenceCount;

const QString syncIndicatorName = "com.nokia.nmail.indicatorplugin.sync/1.0";

/*!

    Constructor

*/

NmUiEngine::NmUiEngine()

: mMailboxListModel(NULL),

  mInboxListModel(NULL),

  mMessageListModel(NULL),

  mMessageSearchListModel(NULL),

  mSendOperation(NULL),

  mRemoveDraftOperation(NULL),

  mSaveDraftOperation(NULL),

  mDraftMessage(NULL)

{

    NM_FUNCTION;

    mPluginFactory = NmDataPluginFactory::instance();

    mDataManager = new NmDataManager();

    // Connect to the plugins to receive change notifications

    QList<QObject*> *dataPlugins = mPluginFactory->pluginInstances();

    for (int i(0); i < dataPlugins->count(); i++) {

        QObject *plugin = (*dataPlugins)[i];

        if (plugin) {

            // connet mailbox events

            QObject::connect(plugin, SIGNAL(mailboxEvent(NmMailboxEvent, const QList<NmId> &)),

                 this, SLOT(handleMailboxEvent(NmMailboxEvent, const QList<NmId> &)),

                 Qt::UniqueConnection);

            // connect message events

            QObject::connect(plugin,

                SIGNAL(messageEvent(NmMessageEvent, const NmId &, const QList<NmId> &, const NmId&)),

                this, SLOT(handleMessageEvent(NmMessageEvent, const NmId &, const QList<NmId> &, const NmId &)),

                Qt::UniqueConnection);

            // connect connection events

            QObject::connect(plugin,

                SIGNAL(connectionEvent(NmConnectState, const NmId &, const int)),

                this,

                SLOT(handleConnectEvent(NmConnectState, const NmId &, const int)),

                Qt::UniqueConnection);

            // do the subscriptions also

            NmDataPluginInterface *pluginInterface = mPluginFactory->interfaceInstance(plugin);

            if (pluginInterface) {

                QList<NmId> mailboxIdList;

                pluginInterface->listMailboxIds(mailboxIdList);

                for (int j(0); j < mailboxIdList.count(); j++) {

                    pluginInterface->subscribeMailboxEvents(mailboxIdList[j]);

                }

                mailboxIdList.clear();

            }

        }

    }

}

/*!

    Class destructor.

*/

NmUiEngine::~NmUiEngine()

{

    NM_FUNCTION;

    enableSyncIndicator(false);

    if (mMessageSearchListModel) {

        delete mMessageSearchListModel;

        mMessageSearchListModel = NULL;

    }

    if (mInboxListModel) {

        delete mInboxListModel;

        mInboxListModel = NULL;

    }

    if (mMessageListModel) {

        delete mMessageListModel;

        mMessageListModel = NULL;

    }

    if (mMailboxListModel) {

        delete mMailboxListModel;

        mMailboxListModel = NULL;

    }

    // Do the unsubscriptions.

    QList<NmId> mailboxIdList;

    mDataManager->listMailboxIds(mailboxIdList);

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

        NmId id = mailboxIdList[i];

        NmDataPluginInterface *pluginInterface =

            mPluginFactory->interfaceInstance(id);

        if (pluginInterface) {

            pluginInterface->unsubscribeMailboxEvents(id);

        }

    }

    mailboxIdList.clear();

    NmDataPluginFactory::releaseInstance(mPluginFactory);

    delete mDataManager;

    // Cancel all operations.

    if (mSendOperation && mSendOperation->isRunning()) {

        mSendOperation->cancelOperation();

    }

    if (mRemoveDraftOperation && mRemoveDraftOperation->isRunning()) {

        mRemoveDraftOperation->cancelOperation();

    }

    if (mSaveDraftOperation && mSaveDraftOperation->isRunning()) {

        mSaveDraftOperation->cancelOperation();

    }

    // Call processEvents() to ensure that the cancelled operations get the time

    // they need to destroy themselves.

    qApp->processEvents();

    if(mDraftMessage) {

        delete mDraftMessage;

        mDraftMessage = NULL;

    }

}

/*!

*/

NmUiEngine *NmUiEngine::instance()

{

    NM_FUNCTION;

    if (!mInstance) {

    	mInstance = new NmUiEngine();

    }

    mReferenceCount++;

    return mInstance;

}

/*!

*/

void NmUiEngine::releaseInstance(NmUiEngine *&instance)

{

    NM_FUNCTION;

    //can't have passed out instances if we don't have any

    if (mInstance) {

        if(instance == mInstance) {

            instance = NULL;

            mReferenceCount--;

        }

        if (0 >= mReferenceCount) {

            delete mInstance;

            mInstance = NULL;

        }

    }

}

/*!

    Returns a list model populated with the mailbox and top level folder objects. The model is

    updated dynamically. The ownership of the model object is not moved to the caller.

*/

NmMailboxListModel &NmUiEngine::mailboxListModel()

{

    NM_FUNCTION;

    if (!mMailboxListModel) {

        refreshMailboxListModel(); // creates the model too

    }

    return *mMailboxListModel;

}

/*!

    Populate the list model with the mailbox and top level folder objects. The model is

    updated dynamically. Creates the model if needed.

*/

void NmUiEngine::refreshMailboxListModel()

{

    NM_FUNCTION;

    if (!mMailboxListModel) {

        mMailboxListModel = new NmMailboxListModel(*mDataManager);

        // Connect the model to the plugins to receive change notifications

        QList<QObject*> *dataPlugins = mPluginFactory->pluginInstances();

        for (int i = 0; i < dataPlugins->count(); i++) {

            QObject *plugin = (*dataPlugins)[i];

            if (plugin) {

                connect(plugin, SIGNAL(mailboxEvent(NmMailboxEvent, const QList<NmId> &)),

                    mMailboxListModel, SLOT(handleMailboxEvent(NmMailboxEvent, const QList<NmId> &)));

            }

        }

    } else {

        mMailboxListModel->clear();

    }

    QList<NmMailbox*> mailboxList;

    mDataManager->listMailboxes(mailboxList);

    mMailboxListModel->refresh(mailboxList);

    while (!mailboxList.isEmpty()) {

        delete mailboxList.takeFirst();

    }

}

/*!

    Returns a message list model for a folder identified by \a mailboxId and

    \a folderId. The model is updated dynamically. The ownership of the model

    object is not moved to the caller.

*/

NmMessageListModel &NmUiEngine::messageListModel(const NmId &mailboxId,

                                                 const NmId &folderId)

{

    NM_FUNCTION;

    QObject *plugin = mPluginFactory->pluginInstance(mailboxId);

    bool isInbox(false);

    if (standardFolderId(mailboxId,NmFolderInbox)==folderId){

        isInbox=true;

    }

    if (plugin) {

        // Connect plugin message events to handler slot messageEventForListModel

        QObject::connect(plugin, SIGNAL(messageEvent(NmMessageEvent, const NmId &,

                                const QList<NmId> &, const NmId&)),

                                this, SLOT(messageEventForListModel(NmMessageEvent,

                                const NmId &, const QList<NmId> &, const NmId&)), Qt::UniqueConnection );

        // Create inbox list model only once when entering to inbox for the first time

        // or re-create inbox list model when mailbox has changed

        if ((!mInboxListModel&&isInbox)||

            (mInboxListModel&&isInbox&&mailboxId!=mInboxListModel->currentMailboxId())){

            // Delete previous model and set to NULL. Deleting model will also

            // delete all items in model.

            if (mInboxListModel){

                delete mInboxListModel;

                mInboxListModel=NULL;

            }

            // Create new inbox model

            mInboxListModel = new NmMessageListModel(*mDataManager);

            // Initial fill up of inbox list model, otherwise updated in the background

            QList<NmMessageEnvelope*> messageEnvelopeList;

            mDataManager->listMessages(mailboxId, folderId, messageEnvelopeList);

            mInboxListModel->refresh(mailboxId, folderId, messageEnvelopeList);

            while (!messageEnvelopeList.isEmpty()) {

                delete messageEnvelopeList.takeFirst();

            }

        }

        // Selected folder is not inbox folder for the mailbox

        else if (!isInbox){

            // Recreate model for other folders when needed, previous model

            // items are deleted from the memory with the old model

            if (mMessageListModel){

                delete mMessageListModel;

                mMessageListModel=NULL;

            }

            mMessageListModel = new NmMessageListModel(*mDataManager);

            // Fill up other model

            QList<NmMessageEnvelope*> messageEnvelopeList;

            mDataManager->listMessages(mailboxId, folderId, messageEnvelopeList);

            mMessageListModel->refresh(mailboxId, folderId, messageEnvelopeList);

            while (!messageEnvelopeList.isEmpty()) {

                delete messageEnvelopeList.takeFirst();

            }

        }

    }

    // Connect sync state changed

    if (plugin){

        QObject::connect(

            plugin, SIGNAL(syncStateEvent(NmSyncState, const NmOperationCompletionEvent &)),

            this, SLOT(handleSyncStateEvent(NmSyncState, const NmOperationCompletionEvent &)),

            Qt::UniqueConnection);

    }

    NmMessageListModel* ret(NULL);

    if (isInbox){

        ret = mInboxListModel;

        // Inbox list model is queried, other model is not

        // needed anymore and memory should be freeded

        if (mMessageListModel){

            delete mMessageListModel;

            mMessageListModel=NULL;

        }

    }

    else {

        ret = mMessageListModel;

    }

    return *ret;

}

/*!

    Returns a message list model used in the search view.

    \param mailboxId The ID of the mailbox to search messages from.

    \return A message list model.

*/

NmMessageListModel &NmUiEngine::messageListModelForSearch(const NmId &mailboxId)

{

    NM_FUNCTION;

    Q_UNUSED(mailboxId);

    if (!mMessageSearchListModel) {

        mMessageSearchListModel = new NmMessageListModel(*mDataManager);

        mMessageSearchListModel->setIgnoreFolderIds(true);

    }

    else {

        mMessageSearchListModel->clear();

    }

    QObject *plugin = mPluginFactory->pluginInstance(mailboxId);

    if (plugin) {

        QObject::connect(plugin,

            SIGNAL(messageEvent(NmMessageEvent, const NmId &, const QList<NmId> &, const NmId &)),

            mMessageSearchListModel,

            SLOT(handleMessageEvent(NmMessageEvent, const NmId &, const QList<NmId> &, const NmId &)),

            Qt::UniqueConnection);

    }

    // Refresh to set the mailbox ID.

    QList<NmMessageEnvelope*> messageEnvelopeList;

    mMessageSearchListModel->refresh(mailboxId, 0, messageEnvelopeList);

    return *mMessageSearchListModel;

}

/*!

    Get the identifier of the standard folder of a type \a folderType

    from the mailbox \a mailboxId.

*/

NmId NmUiEngine::standardFolderId(

    const NmId &mailboxId,

    NmFolderType folderType)

{

    NM_FUNCTION;

    NmId value;

    if (folderType != NmFolderOther) {

        NmDataPluginInterface *plugin =

            mPluginFactory->interfaceInstance(mailboxId);

        if(plugin) {

            value = plugin->getStandardFolderId(mailboxId, folderType);

        }

    }

    return value;

}

/*!

    Returns a message identified by \a mailboxId,  \a folderId and \amessageId.

    The ownership of the  object is moved to the caller.

    Returns null pointer if the message is not found.

*/

NmMessage *NmUiEngine::message(const NmId &mailboxId,

                      const NmId &folderId,

                      const NmId &messageId)

{

    NM_FUNCTION;

    NmMessage *message = mDataManager->message(mailboxId, folderId, messageId);

    return message;

}

/*!

*/

QPointer<NmOperation> NmUiEngine::fetchMessage( const NmId &mailboxId,

    const NmId &folderId,

    const NmId &messageId )

{

    NM_FUNCTION;

    QPointer<NmOperation> value(NULL);

    NmDataPluginInterface *plugin =

        mPluginFactory->interfaceInstance(mailboxId);

    if (plugin) {

        value = plugin->fetchMessage(mailboxId, folderId, messageId);

    }

    return value;

}

/*!

*/

QPointer<NmOperation> NmUiEngine::fetchMessagePart(

    const NmId &mailboxId,

    const NmId &folderId,

    const NmId &messageId,

    const NmId &messagePartId)

{

    NM_FUNCTION;

    QPointer<NmOperation> value(NULL);

    NmDataPluginInterface *plugin =

        mPluginFactory->interfaceInstance(mailboxId);

    if (plugin) {

        value = plugin->fetchMessagePart(mailboxId, folderId, messageId, messagePartId);

    }

    return value;

}

/*!

*/

QPointer<NmOperation> NmUiEngine::fetchMessageParts(

    const NmId &mailboxId,

    const NmId &folderId,

    const NmId &messageId,

    const QList<NmId> &messagePartIds)

{

    NM_FUNCTION;

    QPointer<NmOperation> value(NULL);

    NmDataPluginInterface *plugin =

        mPluginFactory->interfaceInstance(mailboxId);

    if (plugin) {

        value = plugin->fetchMessageParts(mailboxId, folderId, messageId, messagePartIds);

    }

    return value;

}

/*!

*/

XQSharableFile NmUiEngine::messagePartFile(

        const NmId &mailboxId,

        const NmId &folderId,

        const NmId &messageId,

        const NmId &messagePartId)

{

    NM_FUNCTION;

    NmDataPluginInterface *plugin =

        mPluginFactory->interfaceInstance(mailboxId);

    if (plugin) {

        return plugin->messagePartFile(mailboxId, folderId, messageId, messagePartId);

    }

    else {

        // empty file handle

        return XQSharableFile();

    }

}

/*!

    Get content to message part

*/

int NmUiEngine::contentToMessagePart(

    const NmId &mailboxId,

    const NmId &folderId,

    const NmId &messageId,

    NmMessagePart &messagePart)

{

    NM_FUNCTION;

    return mDataManager->contentToMessagePart(mailboxId, folderId, messageId, messagePart);

}

/*!

    Deletes messages from the model and forwards the call to plugin.

    \param mailboxId The ID of the mailbox which contains the deleted message(s).

    \param folderId The ID of the folder which contains the deleted message(s).

    \param messageIdList A list containing the IDs of the message to be deleted.

    \return A possible error code (returned by the plugin).

*/

int NmUiEngine::deleteMessages(const NmId &mailboxId,

                               const NmId &folderId,

                               const QList<NmId> &messageIdList)

{

    NM_FUNCTION;

    int result(NmNotFoundError);

    bool isInbox(false);

    if (standardFolderId(mailboxId,NmFolderInbox)==folderId){

        isInbox=true;

    }

    if (isInbox&&mInboxListModel){

        mInboxListModel->handleMessageEvent(NmMessageDeleted, folderId,

                                               messageIdList, mailboxId);

    }

    else if (mMessageListModel) {

	    mMessageListModel->handleMessageEvent(NmMessageDeleted, folderId,

                                              messageIdList, mailboxId);

	}

	// If the search list model exists and contains message, remove the

	// message from it too.

	if (mMessageSearchListModel && mMessageSearchListModel->rowCount()) {

        mMessageSearchListModel->handleMessageEvent(NmMessageDeleted, folderId,

                                                    messageIdList, mailboxId);