/*

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

/*!

    Constructor

*/

NmUiEngine::NmUiEngine() 

: mMailboxListModel(NULL),

  mMessageListModel(NULL),

  mMessageSearchListModel(NULL),

  mSendOperation(NULL)

{

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

            }

        }

    }

}

/*!

    Destructor

*/

NmUiEngine::~NmUiEngine()

{

    if (mMessageSearchListModel) {

        delete mMessageSearchListModel;

        mMessageSearchListModel = 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;

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

        mSendOperation->cancelOperation();

    }

}

/*!

*/

NmUiEngine *NmUiEngine::instance()

{

    if (!mInstance) {

    	mInstance = new NmUiEngine();

    }

    mReferenceCount++;

    return mInstance;

}

/*!

*/

void NmUiEngine::releaseInstance(NmUiEngine *&instance)

{

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

{

    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()

{

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

    }

}

/*!

*/

{

        mMessageListModel = new NmMessageListModel(*mDataManager);

    }

        mMessageListModel->clear();

    }

    if (plugin) {

        QObject::connect(plugin,

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

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

            Qt::UniqueConnection );

        QObject::connect(

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

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

    }

    QList<NmMessageEnvelope*> messageEnvelopeList;

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

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

    while (!messageEnvelopeList.isEmpty()) {

        delete messageEnvelopeList.takeFirst();

    }

    return *mMessageListModel;

}

/*!

*/

{

    if (!mMessageSearchListModel) {

    }

    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)

{

    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)

{

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

    return message;

}

/*!

*/

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

    const NmId &folderId,

    const NmId &messageId )

{

    NMLOG("NmUiEngine::fetchMessage() <---");

    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)

{

    NMLOG("NmUiEngine::fetchMessagePart() <---");

    QPointer<NmOperation> value(NULL);

    NmDataPluginInterface *plugin =

        mPluginFactory->interfaceInstance(mailboxId);

    if (plugin) {

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

    }

    return value;

}

/*!

*/

XQSharableFile NmUiEngine::messagePartFile(

        const NmId &mailboxId,

        const NmId &folderId,

        const NmId &messageId,

        const NmId &messagePartId)

{

    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)

{

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

}

/*!

    Deletes messages from model and routes call to plugin

*/

int NmUiEngine::deleteMessages(

	const NmId &mailboxId,

	const NmId &folderId,

	const QList<NmId> &messageIdList)

{

    int result(NmNotFoundError);

	if (mMessageListModel) {

	    mMessageListModel->handleMessageEvent(NmMessageDeleted, folderId, messageIdList);

	}

    NmDataPluginInterface *plugin =

            mPluginFactory->interfaceInstance(mailboxId);

    if (plugin) {

          result = plugin->deleteMessages(

	            mailboxId, folderId, messageIdList);

    }

	return result;

}

/*!

    Sets envelope property given in argument.

    Operation is automatically deleted after completion or cancelling.

*/

QPointer<NmStoreEnvelopesOperation> NmUiEngine::setEnvelopes(

        const NmId &mailboxId,

        const NmId &folderId,

        NmEnvelopeProperties property,

        const QList<const NmMessageEnvelope*> &envelopeList)

{

    NMLOG("NmUiEngine::setEnvelopes() <---");

    QPointer<NmStoreEnvelopesOperation> operation(NULL);

    if (mMessageListModel && envelopeList.count()) {

        QList<NmId> messageIdList;

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

            messageIdList.append(envelopeList[i]->messageId());

        }

        mMessageListModel->setEnvelopeProperties(

                           property, messageIdList);

        // Store new envelopes to plugin

        NmDataPluginInterface *plugin =

            mPluginFactory->interfaceInstance(mailboxId);

        if (plugin) {

            operation = plugin->storeEnvelopes(

                    mailboxId, folderId, envelopeList);

        }

        messageIdList.clear();

    }  

    NMLOG("NmUiEngine::setEnvelopes() --->");

    return operation;

}

/*!

    Returns a mailbox meta data object from model with the ID \a mailboxId.

    Ownership of the return value is not moved to the caller.

    Returns NULL if the mailbox is not found.

*/

NmMailboxMetaData *NmUiEngine::mailboxById(const NmId &mailboxId)

{

    NmMailboxMetaData *meta(NULL);

    if (mMailboxListModel) {

	    for (int i(0); i < mMailboxListModel->rowCount(); i++) {

	        QModelIndex index = mMailboxListModel->index(i,0);

	        NmMailboxMetaData *mailbox =

	            mMailboxListModel->data(index, Qt::DisplayRole).value<NmMailboxMetaData*>();

	        if (mailbox && mailbox->id() == mailboxId) {

	            meta = mailbox;

	            break;

	        }

	    }

    }

    return meta;

}

/*!

    Creates a new message (into Drafts-folder).

    Operation is automatically deleted after completion or cancelling.

*/

QPointer<NmMessageCreationOperation> NmUiEngine::createNewMessage(const NmId &mailboxId)

{

    NMLOG("NmUiEngine::createNewMessage() <---");

    QPointer<NmMessageCreationOperation> value(NULL);

    NmDataPluginInterface *plugin =

        mPluginFactory->interfaceInstance(mailboxId);

    if (plugin) {

        value = plugin->createNewMessage(mailboxId);

    }

    return value;

}

/*!

    Creates a new forward message (into Drafts-folder).

    Operation is automatically deleted after completion or cancelling.

*/

QPointer<NmMessageCreationOperation> NmUiEngine::createForwardMessage(

        const NmId &mailboxId,

        const NmId &originalMessageId)

{

    NMLOG("NmUiEngine::createForwardMessage() <---");

    QPointer<NmMessageCreationOperation> value(NULL);

    NmDataPluginInterface *plugin =

        mPluginFactory->interfaceInstance(mailboxId);

    if (plugin) {

        value = plugin->createForwardMessage(mailboxId, originalMessageId);

    }

    return value;

}

/*!

    Creates a new reply message (into Drafts-folder).

    Operation is automatically deleted after completion or cancelling.

*/

QPointer<NmMessageCreationOperation> NmUiEngine::createReplyMessage(

        const NmId &mailboxId,

        const NmId &originalMessageId,

        bool replyAll)

{

    NMLOG("NmUiEngine::createReplyMessage() <---");

    QPointer<NmMessageCreationOperation> value(NULL);

    NmDataPluginInterface *plugin =

        mPluginFactory->interfaceInstance(mailboxId);