/*

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

static const int NmFolderTypeRole = Qt::UserRole+1; 

/*!

    \class NmMessageListModel

    \brief The NmMessageListModel class represents data model for mailbox list.

    @alpha

    The NmMessageListModel class uses NmMessageEnvelope class to represent data returned in its'

    data method to get all information needed for one list row for a widget by calling the method

    once.

*/

/*!

	Class constructor.

*/

NmMessageListModel::NmMessageListModel(NmDataManager &dataManager,

                                       QObject *parent /* = 0 */)

: QStandardItemModel(parent),

  mDataManager(dataManager),

  mDividersActive(false),

  mParentPtr(NULL),

  mCurrentFolderType(NmFolderInbox),

  mIgnoreFolderIds(false)

{

    NM_FUNCTION;

    // Check for setting whether dividers are active

    // mDividersActive = ...

    // update also the test cases

}

/*!

	Class destructor.

*/

NmMessageListModel::~NmMessageListModel()

{

    NM_FUNCTION;

    clear();

}

/*!

    Returns data specified by \a index. Only Qt::DisplayRole is supported in \a role.

    The refresh method must have been called before this method can return any real data.

*/

QVariant NmMessageListModel::data(const QModelIndex &index, int role) const

{

    NM_FUNCTION;

    QVariant qVariant;

    if (index.isValid()){

        if (role == Qt::DisplayRole) {

            NmMessageListModelItem *item =

                static_cast<NmMessageListModelItem*>(itemFromIndex(index));

            qVariant = QVariant::fromValue(item);

        }

        else if (role == NmFolderTypeRole) {

            qVariant = QVariant(mCurrentFolderType);

        }    

    }

    return qVariant;

}

/*!

    This refreshes the data of the model.

    \param mailboxId The ID of the mailbox.

    \param folderId The ID of the folder.

    \param messageEnvelopeList A list containing the message meta data.

*/

void NmMessageListModel::refresh(

        const NmId mailboxId, 

        const NmId folderId,

        const QList<NmMessageEnvelope*> &messageEnvelopeList)

{

    NM_FUNCTION;

    // Store the current mailbox and folder IDs.

    mCurrentMailboxId = mailboxId;

    mCurrentFolderId = folderId;

    // Store the type of the currently displayed folder.

    mCurrentFolderType = mDataManager.folderTypeById(mailboxId, folderId);

    // Clear the model.

    clear();

    // Add the items from the given list.

    NmMessageEnvelope* insertedMessage(NULL);

    int parentCount(0);

    int childCount(0);

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

        NmMessageEnvelope *nextMessage = messageEnvelopeList[i];

        // imap and pop is using common sent, outbox or draft folder

        // for all mailboxes, here we want to filter out messages that

        // are not under this mailbox

        bool insert(true);

        if (nextMessage 

            && (NmFolderSent == mCurrentFolderType

             || NmFolderOutbox == mCurrentFolderType

             || NmFolderDrafts == mCurrentFolderType)) {

            insert = (mCurrentMailboxId == nextMessage->mailboxId());  

        }

        if (insert) {

            if (mDividersActive &&

                !messagesBelongUnderSameDivider(insertedMessage, nextMessage)) {

                insertDividerIntoModel(nextMessage, parentCount);

                parentCount++;

                childCount = 0;

            }

            insertMessageIntoModel(nextMessage, childCount, false);

            insertedMessage = nextMessage;

            childCount++;

        }

    }

}

/*!

    insertDividerIntoModel. Function inserts divider into model.

*/

void NmMessageListModel::insertDividerIntoModel(

    NmMessageEnvelope *messageForDivider,

    int parentRow)

{

    NM_FUNCTION;

    mParentPtr = createTitleDividerItem(messageForDivider);

    insertRow(parentRow,mParentPtr);

    mParentPtr->callEmitDataChanged();

}

/*!

    Function inserts message into model. Message can be inserted

    either to root or to parent. If parent is zero, item is added into root.

*/

void NmMessageListModel::insertMessageIntoModel(

		NmMessageEnvelope *messageEnvelope, int childRow, bool emitSignal)

{

    NM_FUNCTION;

    NmMessageListModelItem *mailItem = createMessageItem(messageEnvelope);

    if (mParentPtr) {

        // Add under parent divider

        mParentPtr->insertRow(childRow, mailItem);

    }

    else {

        // No dividers, add under root item

        insertRow(childRow,mailItem);

    }

    if (emitSignal) {

        mailItem->callEmitDataChanged();

    }

}

/*!

    Function checks whether the messages can be drawn under same title divider

    Check is done depending of the current sorting criteria

*/

bool NmMessageListModel::messagesBelongUnderSameDivider(

    const NmMessageEnvelope *message1,

    const NmMessageEnvelope *message2) const

{

    NM_FUNCTION;

    bool retVal(false);

    // First check pointer validity

    if (message1 && message2) {

        // Switch here for other sort modes 

        // Date based comparison

        QDateTime sentTime1 = message1->sentTime().toLocalTime();

        QDateTime sentTime2 = message2->sentTime().toLocalTime();

        if ( sentTime1.date() == sentTime2.date()) {

            retVal = true;

        }

    }

    return retVal;

}

/*!

    Handles the message events.

    \param event The type of the message event.

    \param folderId The folder containing the message.

    \param messageIds A list of message IDs related to the event.

*/

void NmMessageListModel::handleMessageEvent(NmMessageEvent event,

                                            const NmId &folderId,

                                            const QList<NmId> &messageIds,

                                            const NmId &mailboxId)

{

    NM_FUNCTION;

    const int idCount = messageIds.count();

    // Folder ID does not concern us if this model instance is used for e.g.

    // searching messages.

    if (!mIgnoreFolderIds) {

        if (folderId == 0) {

            // Const cast is used here because also the input parameter has to

            // be changed.

            const_cast<NmId&>(folderId) =

                mDataManager.getStandardFolderId(mailboxId, NmFolderInbox);

            NmUiStartParam *startParam =

                new NmUiStartParam(NmUiViewMessageList, mailboxId, folderId);

            emit setNewParam(startParam);

        }

        if (mCurrentFolderId == 0) {

            // Folder ID was not known at time when the mailbox opened and we

            // know that because of events the subscription is valid only for

            // the current mailbox.

            mCurrentFolderId = folderId; 

        }

        // MailboxId checking here is done because we want to filter out messages

        // that belongs to other mailboxes in case of imap/pop sent, outbox or draft folder

        if (mCurrentFolderId != folderId || mCurrentMailboxId != mailboxId) {

            // The event does not concern the folder currently being displayed.

            // Thus, ignore it.

            return;

        }

    }

    // Go through the given message IDs and do the appropriate operations

    // according to the type of the event.

    for (int i(0); i < idCount; ++i) {

        switch (event) {

            case NmMessageChanged: {

                updateMessageEnvelope(mailboxId, folderId, messageIds[i]);

                break;

            }

            case NmMessageCreated: {

                // mIgnoreFolderIds is true if (and only if) this model is used

                // for mail search purposes and thus, we do not want the model

                // to handle "message created" events. Issue to consider:

                // renaming mIgonreFolderIds => mModelUsedForSearch or something

                // similar.

                if (!mIgnoreFolderIds && !itemFromModel(messageIds[i])) {

                    insertNewMessageIntoModel(mailboxId, folderId, messageIds[i]);

                }

                break;

            }

            case NmMessageFound: {

                if (!itemFromModel(messageIds[i])) {

                    insertNewMessageIntoModel(mailboxId, folderId, messageIds[i]);

                }

                break;

            }

            case NmMessageDeleted: {

                removeMessageFromModel(messageIds[i]);

                break;

            }

        }

    }

}

/*!

    Function inserts new message into correct position to model.

    A new title divider is created if it is needed.

*/

void NmMessageListModel::insertNewMessageIntoModel(

    const NmId &mailboxId,

    const NmId &folderId,

    const NmId &msgId)

{

    NM_FUNCTION;

    // envelope ownership is here

    NmMessageEnvelope *newMsgEnve = mDataManager.envelopeById(mailboxId, folderId, msgId);

    if (newMsgEnve) {

        int rowIndex(getInsertionIndex(*newMsgEnve));

        if (!mDividersActive) {

            if (rowIndex > -1){

                insertMessageIntoModel(newMsgEnve, rowIndex, true);

            } else {

                NmMessageListModelItem *mailItem = createMessageItem(newMsgEnve);

                appendRow(mailItem);

                mailItem->callEmitDataChanged();

            }

        } else {

            // model contain items, message goes to the middle of the list

            if (rowIndex > 0) {

                int dividerIndex(0);

                QList<QStandardItem*> items = findItems("*", Qt::MatchWildcard | Qt::MatchRecursive);

                QModelIndex index = items[rowIndex]->index();

                NmMessageListModelItem *item = static_cast<NmMessageListModelItem*>(itemFromIndex(index));

                NmMessageEnvelope *replacedEnve = item->envelopePtr();

                if (messagesBelongUnderSameDivider(newMsgEnve,replacedEnve)) {

                    // find the index of the divider and insert message as child object

                    // dividerIndex is not actually used here but function sets

                    // the correct parent pointer

                    dividerIndex = dividerInsertionIndex(rowIndex);

                    insertMessageIntoModel(newMsgEnve, 0, true);

                } else {

                    // create new divider and find the correct index for it

                    dividerIndex = dividerInsertionIndex(rowIndex);

                    insertDividerIntoModel(newMsgEnve, dividerIndex);

                    // Insert message as a first child under new divider

                    insertMessageIntoModel(newMsgEnve, 0, true);

                }

                items.clear();

            }

            // first mail item in the model,

            // insert new divider to index 0 and new message as a child.

            else if (0 == rowIndex) {

                insertDividerIntoModel(newMsgEnve, rowIndex);

                insertMessageIntoModel(newMsgEnve, 0, true);

            }

            // this will go to the last item of the list and create new title divider

            else {

                mParentPtr = createTitleDividerItem(newMsgEnve);

                appendRow(mParentPtr);

                mParentPtr->callEmitDataChanged();

                NmMessageListModelItem *mailItem = createMessageItem(newMsgEnve);

                // Add under parent divider

                mParentPtr->appendRow(mailItem);

                mailItem->callEmitDataChanged();

            }

        }

    }

    delete newMsgEnve;

}

/*!

    Function check model index in which the new message should be inserted

    with the currently active sort mode.

*/

int NmMessageListModel::getInsertionIndex(

    const NmMessageEnvelope &envelope) const

{

    NM_FUNCTION;

    int ret(NmNotFoundError);

    // Date+descending sort mode based comparison.

    // Go through model and compare sent times with QDateTime >= comparison operation.

    QList<QStandardItem*> items = findItems("*", Qt::MatchWildcard | Qt::MatchRecursive);

    int count(items.count());

    bool found(false);

    int i(0);

    while (i < count && !found) {

        QModelIndex index = items[i]->index();

        NmMessageListModelItem *item = static_cast<NmMessageListModelItem*>(itemFromIndex(index));

        if (NmMessageListModelItem::NmMessageItemMessage == item->itemType()) {

        	found = envelope.sentTime() >= item->envelope().sentTime();

        	if (found) {

                ret = i;

        	}

        }

        i++;

    }

    if (0 == count) {

        ret = NmNoError;

    }

    items.clear();

    return ret;

}

/*!

    Function finds preceding title divider index and sets the

    mParentPtr variable.

*/

int NmMessageListModel::dividerInsertionIndex(int messageIndex)

{

    NM_FUNCTION;

    bool found(false);

    int ret(NmNoError);

    QModelIndex index;

    QList<QStandardItem*> items = findItems("*", Qt::MatchWildcard | Qt::MatchRecursive);

    for (int i = messageIndex-1; i >= 0 && !found; i--) {

        index = items[i]->index();

        NmMessageListModelItem *item = static_cast<NmMessageListModelItem*>(itemFromIndex(index));

        if(item->itemType() == NmMessageListModelItem::NmMessageItemTitleDivider) {

            found = true;

            mParentPtr = static_cast<NmMessageListModelItem*>(itemFromIndex(index));

            ret = index.row();

        }

    }

    items.clear();

    return ret;

}

/*!

    Create title divider item

*/

NmMessageListModelItem *NmMessageListModel::createTitleDividerItem(

		NmMessageEnvelope *messageForDivider)

{

    NM_FUNCTION;

    NmMessageListModelItem *item = new NmMessageListModelItem();

    item->setItemType(NmMessageListModelItem::NmMessageItemTitleDivider);

    QDate sentLocalDate = messageForDivider->sentTime().toLocalTime().date();

    QDate currentdate = QDate::currentDate();

    if (sentLocalDate == currentdate) {

        // NOTE: when dividers are taken in to use hbTrId macro should used here,

        // to be clarified how to access ts-file (located under ui component)

        item->setTitleDivider(tr("Today", "txt_nmailuiengine_divider_today"));

        item->setText(tr("Today", "txt_nmailuiengine_divider_today"));

    }

    else {

        QLocale locale;

        QString divider = locale.toString(sentLocalDate, QLocale::LongFormat);

        item->setTitleDivider(divider);

        item->setText(divider);

        }

    item->setEnvelope(*messageForDivider);

    item->setData(Hb::ParentItem, Hb::ItemTypeRole);

    return item;

}

/*!

    Create message item

*/

NmMessageListModelItem *NmMessageListModel::createMessageItem(

		NmMessageEnvelope *envelope)

{

    NM_FUNCTION;

    NmMessageListModelItem *mailItem = new NmMessageListModelItem();

    mailItem->setEnvelope(*envelope);

    mailItem->setItemType(NmMessageListModelItem::NmMessageItemMessage);

    mailItem->setData(Hb::StandardItem, Hb::ItemTypeRole);

    return mailItem;

}

/*!

    Returns divider state

*/

bool NmMessageListModel::dividersActive()

{

    NM_FUNCTION;

    return mDividersActive;

}

/*!

    Set divider state

*/

void NmMessageListModel::setDividers(bool active)

{

    NM_FUNCTION;

    mDividersActive = active;

}

/*!

   Change item property if differs

*/

void NmMessageListModel::setEnvelopeProperties(

    NmEnvelopeProperties property,

    const QList<NmId> &messageIds)

{

    NM_FUNCTION;

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

        updateEnvelope(property, messageIds[i]);

    }

}

/*!

    Returns the ID of the current mailbox.

*/

NmId NmMessageListModel::currentMailboxId()

{

    NM_FUNCTION;

    return mCurrentMailboxId;

}

/*!

    Sets whether the model should ignore the folder IDs or not. The folder IDs

    should be ignored e.g. when the model is used for searching messages

    (i.e. used by the search view).

    \param ignore If true, will ignore the folder IDs.

*/

void NmMessageListModel::setIgnoreFolderIds(bool ignore)

{

    NM_FUNCTION;

    mIgnoreFolderIds = ignore;

}

/*!

   Remove message from model if message exists in model

*/

void NmMessageListModel::removeMessageFromModel(const NmId &msgId)

{

    NM_FUNCTION;

    QList<QStandardItem*> items = findItems("*", Qt::MatchWildcard | Qt::MatchRecursive);

    int count(items.count());

    bool found(false);