/*

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

#include "nmapidataplugininterface.h"

#include "nmapidatapluginfactory.h"

#include "nmapiengine.h"

NmEngine *NmEngine::mInstance = NULL;

quint32 NmEngine::mReferenceCount = 0;

/*!

 \class NmEngine

 \brief The NmEngine class provides access to data for

 mailboxes, folders and messages. If the dataplugin can't be loaded, fatal assert is called.

 */

/*!

 Private constructor

 */

NmEngine::NmEngine() :

    mFactory(NULL)

{

    mFactory = NmDataPluginFactory::instance();

    Q_ASSERT(mFactory->pluginInstances()->count() > 0);

}

/*!

 Destructor

 */

NmEngine::~NmEngine()

{

    NmDataPluginFactory::releaseInstance(mFactory);

}

/*!

 * Creates instance of NmEngine and prvide pointer to it.

 * 

 * If engine exist, it increase references count and provide pointer to it.

 * 

 * \return Instance of engine

 */

NmEngine* NmEngine::instance()

{

    if (!mInstance) {

        mInstance = new NmEngine();

    }

    mReferenceCount++;

    return mInstance;

}

/*!

 * Creates connections for events from email store.

 */

void NmEngine::startCollectingEvents()

{

    QList<QObject*>* pluginList = mFactory->pluginInstances();

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

        QObject* plugin = pluginList->at(i);

        QObject::connect(plugin, SIGNAL(messageEvent(NmMessageEvent, NmId, QList<NmId> , NmId)),

            this, SLOT(messageChangedArrived(NmMessageEvent, NmId, QList<NmId> , NmId)),

            Qt::UniqueConnection);

        connect(plugin, SIGNAL(mailboxEvent(NmMailboxEvent, QList<NmId> )), this, SLOT(

            mailboxChangedArrived(NmMailboxEvent, QList<NmId> )), Qt::UniqueConnection);

    }

}

/*!

 * It process mailbox ids from email store for given event.

 * On end it emit \sa emailStoreEvent

 * 

 * \arg Event of mailbox change

 * \arg List of mailbox ids for that event 

 */

void NmEngine::mailboxChangedArrived(NmMailboxEvent mailboxEvent, const QList<NmId> &mailboxIds)

{

    NmApiMessage message;

    message.objectType = EMailbox;

    switch (mailboxEvent) {

        case NmMailboxCreated: {

            message.action = ENew;

        }

            break;

        case NmMailboxDeleted: {

            message.action = EDeleted;

        }

            break;

        case NmMailboxChanged: {

            message.action = EChange;

        }

            break;

        default:

            break;

    }

    message.folderId = 0;

    message.mailboxId = 0;

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

        message.objectIds.append(mailboxIds.at(i).id());

    }

    emit emailStoreEvent(message);

}

/*!

 * It process message ids from email store for given event.

 * On end it emit \sa emailStoreEvent

 * 

 * \arg Event of message change

 * \arg List of message ids for that event 

 */

void NmEngine::messageChangedArrived(

    NmMessageEvent messageEvent,

    const NmId &folderId,

    const QList<NmId> &messageIds,

    const NmId &mailboxId)

{

    NmApiMessage message;

    message.objectType = EMessage;

    switch (messageEvent) {

        case NmMessageCreated: {

            message.action = ENew;

        }

            break;

        case NmMessageDeleted: {

            message.action = EDeleted;

        }

            break;

        case NmMessageChanged: {

            message.action = EChange;

        }

            break;

        default:

            break;

    }

    message.folderId = folderId.id();

    message.mailboxId = mailboxId.id();

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

        message.objectIds.append(messageIds.at(i).id());

    }

    emit emailStoreEvent(message);

}

/*!

 * Release instance of engine if there are not referenced objects. 

 * If there are refenced objects it only decrease refenced count.

 * 

 * \arg Instance of engine

 */

void NmEngine::releaseInstance(NmEngine *&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;

        }

    }

}

/*!

 *    It get all mailboxes from email store

 *    

 *    \sa EmailClientApi::NmMailbox

 *    \arg List of mailboxes to be filled.

 */

void NmEngine::listMailboxes(QList<EmailClientApi::NmMailbox> &mailboxList)

{

    QList<NmMailbox*> mailboxFromPlugin;

    int count = mFactory->pluginInstances()->count();

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

        NmDataPluginInterface *instance = mFactory->interfaceInstance(

            mFactory->pluginInstances()->at(i));

        if (instance) {

            instance->listMailboxes(mailboxFromPlugin);

        }

    }

    while (mailboxFromPlugin.isEmpty() == false) {

        NmMailbox* tempNmMailbox = mailboxFromPlugin.takeFirst();

        mailboxList << NmToApiConverter::NmMailbox2ApiNmMailbox(*tempNmMailbox);

        delete tempNmMailbox;

    }

}

/*!

 *    It get all folders from email store for given mailbox

 *    

 *    \sa EmailClientApi::NmFolder

 *    \arg Mailbox id from where folders should be returned

 *    \arg List of folders to be filled.

 */

void NmEngine::listFolders(const quint64 mailboxId, QList<EmailClientApi::NmFolder> &folderList)

{

    QList<NmFolder*> folderFromPlugin;

    NmDataPluginInterface *instance = mFactory->interfaceInstance(mailboxId);

    if (instance) {

        instance->listFolders(mailboxId, folderFromPlugin);

    }

    while (folderFromPlugin.isEmpty() == false) {

        NmFolder* tempNmFolder = folderFromPlugin.takeFirst();

        folderList << NmToApiConverter::NmFolder2ApiNmFolder(*tempNmFolder);

        delete tempNmFolder;

    }

}

/*!

 *    It get all envelopes from email store for given mailbox and folder

 *    

 *    \sa EmailClientApi::NmMessageEnvelope

 *    \arg Mailbox id from where envelope should be returned

 *    \arg Folder id from where envelope should be returned

 *    \arg List of envelopes to be filled.

 */

void NmEngine::listEnvelopes(const quint64 mailboxId, const quint64 folderId, QList<

    EmailClientApi::NmMessageEnvelope> &messageEnvelopeList)

{

    QList<NmMessageEnvelope*> envelopes;

    NmDataPluginInterface *instance = mFactory->interfaceInstance(folderId);

    if (instance) {

        instance->listMessages(mailboxId, folderId, envelopes);

    }

    while (!envelopes.isEmpty()) {

        NmMessageEnvelope* env = envelopes.takeFirst();

        EmailClientApi::NmMessageEnvelope nmEnvelope =

            NmToApiConverter::NmMessageEnvelope2ApiEnvelope(*env);

        NmMessage* message = new NmMessage();

        instance->getMessageById(mailboxId, folderId, nmEnvelope.id(), message);

        QString plainText = QString();

        if (message->plainTextBodyPart()) {

            plainText = message->plainTextBodyPart()->textContent();

        }

        nmEnvelope.setPlainText(plainText);

        nmEnvelope.setFetchedSize(message->fetchedSize());

        nmEnvelope.setTotalSize(message->size());

        messageEnvelopeList << nmEnvelope;

        delete env;

    }

}

/*!

 * Return envelope given by mailbox, folder and envelope id.

 * 

 * \arg Mailbox id from where envlope should come

 * \arg Folder id from where envlope should come

 * \arg Id of envelope which should be returned

 * \arg Envelope to fill.

 * 

 * \return Return true if it will find any envelope

 */

bool NmEngine::envelopeById(

    const quint64 mailboxId,

    const quint64 folderId,

    const quint64 envelopeId,

    EmailClientApi::NmMessageEnvelope& envelope)

{

    QList<EmailClientApi::NmMessageEnvelope> envelopes;

    listEnvelopes(mailboxId, folderId, envelopes);

    //flag indicating that envelope with given id was found

    bool found = false;

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

        if (envelopes.at(i).id() == envelopeId) {

            envelope = envelopes.at(i);

            found = true;

            break;

        }

    }

    return found ? true : false;

}

/*!

 * Return mailbox given by mailbox id.

 * 

 * \arg Id of Mailbox which should be returned

 * \arg Mailbox to fill.

 * 

 * \return Return true if it will find any envelope

 */

bool NmEngine::mailboxById(const quint64 mailboxId, EmailClientApi::NmMailbox &mailbox)

{

    NmDataPluginInterface *instance = mFactory->interfaceInstance(mailboxId);

    if (!instance) {

        return false;

    }

    NmMailbox *nmmailbox;

    instance->getMailboxById(NmId(mailboxId), nmmailbox);

    if (!nmmailbox) {

        return false;

    }

    mailbox = NmToApiConverter::NmMailbox2ApiNmMailbox(*nmmailbox);

    return true;

}