/*

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