/*

 * Copyright (c) 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: Mail agent is responsible of monitoring mail accounts. It activates

 *              and deactivates indicator depending on received events. Mail agent is

 *              also responsible of monitoring silence mode, playing alert tone and vibrating

 *              phone when new mail is received.

 *

 */

#include "emailtrace.h"

#include "nmmailagentheaders.h"

#include "nmmailagent.h"

#include <xqaiwdeclplat.h>

#include <xqapplicationmanager.h>

#include <xqaiwrequest.h>

#include <xqsettingsmanager.h>

#include <xqcentralrepositoryutils.h>

#include <xqsystemtoneservice.h>

#include <xqsettingskey.h>

#include <ProfileEngineInternalCRKeys.h>

// CONSTANTS

const int NmAgentIndicatorNotSet = -1;

const int NmAgentAlertToneTimer = 60000; // 60s

const int NmAgentDefaultVibraDuration = 1000; // 1 second

static const quint32 NmRepositoryId = 0x2002C326;

static const QString NmMailboxIndicatorType = "com.nokia.nmail.indicatorplugin_%1/1.0";

static const QString NmSendIndicatorName = "com.nokia.nmail.indicatorplugin.send/1.0";

static const QString NmUnreadIndicatorName = "com.nokia.nmail.indicatorplugin.unread/1.0";

const XQCentralRepositorySettingsKey NmSilenceModeKey(KCRUidProfileEngine.iUid, KProEngSilenceMode);

const int NmSilenceModeOn = 1;

/*!

    Helper method for finding out if XQSettingsKey and XQCentralRepositorySettingsKey points to

    same key.

    \param settingKey XQSettingsKey

    \param cenrepSettingKey XQCentralRepositorySettingsKey

    \return <code>true</code> if target, uid and key matches otherwise returns <code>false</code>

 */

bool keysEqual(const XQSettingsKey& settingKey, const XQCentralRepositorySettingsKey& cenrepSettingKey)

{

    return ((settingKey.target() == cenrepSettingKey.target()) &&

        (settingKey.uid() == cenrepSettingKey.uid()) &&

        (settingKey.key() == cenrepSettingKey.key()));

}

/*!

    \class NmMailboxInfo

    \brief Main class for storing mailbox data.

 */

NmMailboxInfo::NmMailboxInfo()

: mId(0),

  mIndicatorIndex(NmAgentIndicatorNotSet),

  mInboxFolderId(0),

  mOutboxFolderId(0),

  mSyncState(SyncComplete),

  mConnectState(Disconnected),

  mInboxCreatedMessages(0),

  mInboxChangedMessages(0),

  mInboxDeletedMessages(0),

  mOutboxMails(0),

  mActive(false),

  mInboxActive(false)

  {

  }

/*!

    \class NmMailAgent

    \brief Main class for receiving email events. Activates and deactivates indicator.

 */

NmMailAgent::NmMailAgent() :

     mIndicator(NULL),

     mSystemTone(NULL),

     mPluginFactory(NULL),

     mVibra(NULL),

     mAlertToneAllowed(true),

     mLastOutboxCount(0),

     mUnreadIndicatorActive(false),

     mSettingManager(NULL),

     mSilenceMode(NmSilenceModeOn)  // by default silent mode is on

     {

     }

/*!

    Delayed start.

 */

void NmMailAgent::delayedStart()

{

    NM_FUNCTION;

    if (!init()) {

        // Initialisation failed. Quit the agent.

        QCoreApplication::exit(1);

    }

}

/*!

    Initialise the agent.

    \return true if succesfully started.

 */

bool NmMailAgent::init()

{

    NM_FUNCTION;

    mPluginFactory = NmDataPluginFactory::instance();

    if (!mPluginFactory) {

        NM_ERROR(1,"NmMailAgent::init(): PluginFactory not created");

        return false;

    }

    // Check status of silent mode.

    delete mSettingManager;

    mSettingManager = NULL;

    mSettingManager = new XQSettingsManager();

    QVariant silenceMode = mSettingManager->readItemValue(NmSilenceModeKey,

        XQSettingsManager::TypeInt);

    mSilenceMode = silenceMode.toInt();

    // Start monitoring silence mode key.

    bool monitoring(mSettingManager->startMonitoring(NmSilenceModeKey, XQSettingsManager::TypeInt));

    monitoring &= connect(mSettingManager,

                          SIGNAL(valueChanged(const XQSettingsKey &, const QVariant &)),

                          this,

                          SLOT(valueChanged(const XQSettingsKey &, const QVariant &)),

                          Qt::UniqueConnection);

    // If silence mode monitoring can't be started, then change silence mode on to be sure

    // that no tone is played if silence mode is turned on at somepoint.

    if (!monitoring) {

        mSilenceMode = NmSilenceModeOn;

    }

    delete mSystemTone;

    mSystemTone = NULL;

    mSystemTone = new XQSystemToneService();

    delete mIndicator;

    mIndicator = NULL;

    mIndicator = new HbIndicator();

    connect(mIndicator,SIGNAL(userActivated(const QString &, const QVariantMap &)),

        this, SLOT(indicatorActivated(const QString &, const QVariantMap &)));

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

    foreach (QObject *plugin, *plugins) {

        if (plugin) {

            // Start listening events

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

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

                    Qt::UniqueConnection);

            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(plugin, SIGNAL(syncStateEvent(NmSyncState, const NmOperationCompletionEvent &)),

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

                Qt::UniqueConnection);

            connect(plugin, SIGNAL(connectionEvent(NmConnectState, const NmId, int)),

                    this, SLOT(handleConnectionEvent(NmConnectState, const NmId, int)),

                    Qt::UniqueConnection);

        }

    }

    // Construct the vibra interface instance.

    delete mVibra;

    mVibra = NULL;

    TRAP_IGNORE(mVibra = CHWRMVibra::NewL());

    // load all current mailboxes

    initMailboxStatus();

    return true;

}

/*!

    Destructor of NmMailAgent.

 */

NmMailAgent::~NmMailAgent()

{

    NM_FUNCTION;

    delete mIndicator;

    delete mVibra;

    delete mSystemTone;

    if (mSettingManager) {

        mSettingManager->stopMonitoring(NmSilenceModeKey);

        delete mSettingManager;

    }

    qDeleteAll(mMailboxes);

    NmDataPluginFactory::releaseInstance(mPluginFactory);

}

/*!

    Initialize the mailbox list with the current state.

 */

void NmMailAgent::initMailboxStatus()

{

    NM_FUNCTION;

    QList<NmMailbox*> mailboxes;

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

    foreach(QObject* pluginObject, *plugins) {

        NmDataPluginInterface *plugin =

            mPluginFactory->interfaceInstance(pluginObject);

        if (plugin) {

            plugin->listMailboxes(mailboxes);

        }

        // Add the indicators

        // Must be made in reverse order to show them properly in

        // HbIndicator menu

        QListIterator<NmMailbox *> i(mailboxes);

        i.toBack();

        while (i.hasPrevious()) {

            const NmMailbox *mailbox = i.previous();

            if (mailbox) {

                NmMailboxInfo *mailboxInfo = createMailboxInfo(*mailbox, plugin);

                if (mailboxInfo) {

                    bool activate = updateUnreadCount(mailbox->id(), *mailboxInfo);

                    bool wasActive = isMailboxActive(mailbox->id());

                    if (activate) {

                        if (!wasActive) {

                            // do not activate the mailbox if it was left as hidden last time

                            activate = false;

                        }

                        else {

                            // otherwise, activate the mailbox and show inbox state

                            mailboxInfo->mInboxActive = true;

                        }

                    }

                    mailboxInfo->mOutboxMails = getOutboxCount(mailbox->id(),

                        mailboxInfo->mOutboxFolderId);

                    if (mailboxInfo->mOutboxMails > 0 && wasActive) {

                        activate = true;

                    }

                    // Create indicator for visible mailboxes

                    updateMailboxState(mailbox->id(), activate, false);

                }

            }

        }

        qDeleteAll(mailboxes);

    }

    updateUnreadIndicator();

    updateSendIndicator();

}

/*!

    Get mailbox unread count in inbox folder.

    \param mailboxId id of the mailbox

    \param mailboxInfo contains the list of unread messages

    \return true if new unread mails was found

 */

bool NmMailAgent::updateUnreadCount(const NmId &mailboxId, NmMailboxInfo &mailboxInfo)

{

    NM_FUNCTION;

    int newUnreadMessages(0);

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

    if (plugin) {

        NmId inboxId = mailboxInfo.mInboxFolderId.id();

        // Inbox folder ID may be still unknown

        if (inboxId == 0) {

            mailboxInfo.mInboxFolderId = plugin->getStandardFolderId(mailboxId, NmFolderInbox);

            inboxId = mailboxInfo.mInboxFolderId.id();

        }

        // get list of messages in inbox

        QList<NmMessageEnvelope*> messageList;

        plugin->listMessages(mailboxId, inboxId, messageList);

        QList<NmId> newUnreadMessageIdList;

        foreach (const NmMessageEnvelope* envelope, messageList) {

            // if the message is not read, it is "unread"

            if (!envelope->isRead()) {

                quint64 messageId = envelope->messageId().id();

                newUnreadMessageIdList.append(envelope->messageId());

                bool found(false);

                // Iterate through all known ids. If the id can't be found the mail is new.

                foreach (const NmId id, mailboxInfo.mUnreadMailIdList) {

                    if (id.id() == messageId) {

                        found = true;

                        break;

                    }

                }

                if (!found) {

                    newUnreadMessages++;

                }

            }

        }

        qDeleteAll(messageList);

        // Save updated list of unread message IDs

        mailboxInfo.mUnreadMailIdList = newUnreadMessageIdList;

    }

    NM_COMMENT(QString("NmMailAgent::getUnreadCount(): count=%1, new=%2").

        arg(mailboxInfo.mUnreadMailIdList.count()).arg(newUnreadMessages));

    return (newUnreadMessages > 0);

}

/*!

    Get mailbox count in outbox folder.

    \param mailboxId id of the mailbox

    \param outboxId Outbox folder Id

    \return number of mails in the outbox

 */

int NmMailAgent::getOutboxCount(const NmId &mailboxId, const NmId &outboxId)

{

    NM_FUNCTION;

    int count(0);

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

    if (plugin) {

        // get list of messages in outbox

        QList<NmMessageEnvelope*> messageList;

        plugin->listMessages(mailboxId, outboxId, messageList);

        count = messageList.count();

        qDeleteAll(messageList);

    }

    NM_COMMENT(QString("NmMailAgent::getOutboxCount(): count=%1").arg(count));

    return count;

}

/*!

    Get list of unread counts in active mailboxes.

	\returns total number of unread mails

 */

int NmMailAgent::getTotalUnreadCount() const

{

    NM_FUNCTION;

    int unreads = 0;

    foreach (const NmMailboxInfo *mailbox, mMailboxes) {

        if (mailbox->mActive && mailbox->mInboxActive) {

            unreads += mailbox->mUnreadMailIdList.count();

        }

    }

    return unreads;

}

/*!

    Update the "@" indicator state according to unread state.

    \return true if the indicator was activated

 */

bool NmMailAgent::updateUnreadIndicator()

{

    NM_FUNCTION;

    int unreads = getTotalUnreadCount();

    return updateUnreadIndicator(unreads>0);

}

/*!

    Update the mailbox visibility and status.

    \param mailboxId id of the mailbox

    \param active visibility state of the mailbox

    \param refreshAlways true when the indicator should be always updated

    \return true if the mailbox state was changed

 */

bool NmMailAgent::updateMailboxState(const NmId &mailboxId,

    bool active, bool refreshAlways)

{

    NM_FUNCTION;

    NmMailboxInfo *mailboxInfo = getMailboxInfo(mailboxId);

    bool changed = false;

    if (mailboxInfo->mActive != active ||

        refreshAlways) {

        // store the new state to permanent storage

        storeMailboxActive(mailboxId, active);

        mailboxInfo->mActive = active;

        changed = true;

        if (active) {

            // Mailbox is not yet assigned to any indicator

            if (mailboxInfo->mIndicatorIndex < 0) {

                mailboxInfo->mIndicatorIndex = getFreeIndicatorIndex();

            }

            updateIndicator(true,*mailboxInfo);

        }

        else {

            // Indicator not anymore active. Release it.

            if (mailboxInfo->mIndicatorIndex>=0) {

                updateIndicator(false,*mailboxInfo);

                mailboxInfo->mIndicatorIndex = NmAgentIndicatorNotSet;

            }

        }

    }

    return changed;

}

/*!

    Updates indicator status.

    \param mailboxIndex index of the item shown in indicator menu

    \param active indicator visibility state

    \param mailboxInfo information of the mailbox

    \return true if indicator was updated with no errors

 */

bool NmMailAgent::updateIndicator(bool active,

    const NmMailboxInfo& mailboxInfo)

{

    NM_FUNCTION;

    NM_COMMENT(QString("NmMailAgent::updateIndicator(): index=%1, active=%2").

        arg(mailboxInfo.mIndicatorIndex).arg(active));

    bool ok = false;

    QString name = QString(NmMailboxIndicatorType).

        arg(mailboxInfo.mIndicatorIndex);

    QList<QVariant> list;

    list.append(mailboxInfo.mId.id());

    list.append(mailboxInfo.mName);

    list.append(mailboxInfo.mUnreadMailIdList.count());

    list.append(mailboxInfo.mSyncState);

    list.append(mailboxInfo.mConnectState);

    list.append(mailboxInfo.mOutboxMails);

    list.append(mailboxInfo.mIconName);

    list.append(mLastOutboxCount);

    if (active) {

        ok = mIndicator->activate(name,list);

    }

    else {

        ok = mIndicator->deactivate(name,list);

    }

    updateUnreadIndicator();

    return ok;

}

/*!

    Update the unread indicator state.

    \param active if true unread indicator is activated otherwise deactivated

    \return true if the indicator was activated

 */

bool NmMailAgent::updateUnreadIndicator(bool active)

{

    NM_FUNCTION;

    bool activated = false;

    if (active != mUnreadIndicatorActive) {

        if (active) {

            mIndicator->activate(NmUnreadIndicatorName);

            activated = true;