/*

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

#include "conversationsenginedefines.h"

#include "conversationmsgstorehandler.h"

#include "convergedmessage.h"

#include "s60qconversions.h"

#include "conversationsengineutility.h"

#include "unidatamodelloader.h"

#include "unidatamodelplugininterface.h"

#include "ringbc.h"

#include "msgcontacthandler.h"

#include <ccsconversationentry.h>

#include "debugtraces.h"

#include <QFile>

#include <QFileInfo>

#include <s32mem.h>

#include <ccsdefs.h>

//CONSTANTS

_LIT(KDbFileName, "c:[2002A542]conversations.db");

// preview sql query

//---------------------------------------------------------------

// ConversationsModel::ConversationsModel

// Constructor

//---------------------------------------------------------------

ConversationsModel::ConversationsModel(ConversationMsgStoreHandler* msgStoreHandler,

    QObject* parent) :

    QStandardItemModel(parent), mMsgStoreHandler(msgStoreHandler), iSqlDbOpen(EFalse)

{

    //Open SQL DB

    if (KErrNone == iSqlDb.Open(KDbFileName))

    {

        iSqlDbOpen = ETrue;

    }

    iDataModelPluginLoader = new UniDataModelLoader;

    iMmsDataPlugin = iDataModelPluginLoader->getDataModelPlugin(ConvergedMessage::Mms);

    iBioMsgPlugin = iDataModelPluginLoader->getDataModelPlugin(ConvergedMessage::BioMsg);

}

//---------------------------------------------------------------

// ConversationsModel::~ConversationsModel

// Destructor

//---------------------------------------------------------------

ConversationsModel::~ConversationsModel()

{

    //Close SQL-DB

    iSqlDb.Close();

    if (iDataModelPluginLoader) {

        delete iDataModelPluginLoader;

        iDataModelPluginLoader = NULL;

    }

}

//---------------------------------------------------------------

// ConversationsModel::data

// @see header

//---------------------------------------------------------------

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

{

    QVariant value;

    QStandardItem* item = itemFromIndex(index);

    switch (role) {

    case ConversationId:

    {

        value = item->data(ConversationId);

        break;

    }

    case UnReadStatus:

    {

        value = item->data(UnReadStatus);

        break;

    }

    case ContactId:

    {

        value = item->data(ContactId);

        break;

    }

    case TimeStamp:

    {

        value = item->data(TimeStamp);

        break;

    }

    case ConvergedMsgId:

    {

        value = item->data(ConvergedMsgId);

        break;

    }

    case MessageProperty:

    {

        value = item->data(MessageProperty);

        break;

    }

    case MessageType:

    {

        value = item->data(MessageType);

        break;

    }

    case MessageSubType:

    {

        value = item->data(MessageSubType);

        break;

    }

    case Subject:

    {

        value = item->data(Subject);

        break;

    }

    case BodyText:

    {

        value = item->data(BodyText);

        break;

    }

    case ConversationAddress:

    {

        value = item->data(ConversationAddress);

        break;

    }

    case Direction:

    {

        value = item->data(Direction);

        break;

    }

    case SendingState:

    {

        value = item->data(SendingState);

        break;

    }

    case MessagePriority:

    {

        value = item->data(MessagePriority);

        break;

    }

    case Attachments:

    {

        value = item->data(Attachments);

        break;

    }

    case MessageLocation:

    {

        value = item->data(MessageLocation);

        break;

    }

    case MessageStore:

    {

        value = item->data(MessageStore);

        break;

    }

    case ConversationAlias:

    {

        value = item->data(ConversationAlias);

        break;

    }

    case UnreadCount:

    {

        value = item->data(UnreadCount);

        break;

    }

    case DisplayName: // Fall through start

        value = item->data(DisplayName);

        break;    

    case Avatar: // Fall througn end

        value = item->data(Avatar);

        break;

    case NotificationStatus:

        value = item->data(NotificationStatus);

        break;

    default:

    {

        //No matching role found, set invalid variant

        value = QVariant();

        break;

    }

    }

    return value;

}

//---------------------------------------------------------------

// ConversationsModel::addRow

// @see header

//---------------------------------------------------------------

void ConversationsModel::addRow(const CCsConversationEntry& entry, bool dynamicUpdate)

{

    int msgId = entry.EntryId();

    //match, if found update else add item

    QModelIndexList indexList = this->match(index(0, 0), ConvergedMsgId, msgId, -1,

        Qt::MatchExactly);

    // if not found, add new item

    if (indexList.count() == 0) {

        QStandardItem* item = new QStandardItem();

        populateItem(*item, entry);

        if (!dynamicUpdate) {

            insertRow(0, item);

        }

        else {

            int i;

            for (i = rowCount() - 1; i >= 0; --i) {

                QStandardItem* modelItem = this->item(i, 0);

                if (modelItem->data(ConvergedMsgId).toInt() < item->data(ConvergedMsgId).toInt()) {

                    if (i == rowCount() - 1) {

                        appendRow(item);

                    }

                    else {

                        insertRow(i + 1, item);

                    }

                    return;

                }

            }

            if (i == 0) {

                insertRow(0, item);

            }

        }

    }

    else {

        // Update an existing item

        QModelIndex index = indexList[0];

        QStandardItem* item = this->item(index.row(), 0);

        populateItem(*item, entry);

    }

}

//---------------------------------------------------------------

// ConversationsModel::deleteRow

// @see header

//---------------------------------------------------------------

void ConversationsModel::deleteRow(int msgId)

{

    //match, if found remove item

    QModelIndexList indexList =

        this->match(index(0, 0), ConvergedMsgId, msgId, 1, Qt::MatchExactly);

    if (indexList.count() == 1) {

        QModelIndex index = indexList[0];

        this->removeRow(index.row());

    }

}

//---------------------------------------------------------------

// ConversationsModel::populateItem

// @see header

//---------------------------------------------------------------

void ConversationsModel::populateItem(QStandardItem& item, const CCsConversationEntry& entry)

{

    QCRITICAL_WRITE("ConversationsModel::populateItem start.");

    int msgId = entry.EntryId();

    // id

    item.setData(msgId, ConvergedMsgId);

    // description

    HBufC* description = entry.Description();

    QString subject("");

    if (description && description->Length()) {

        subject = (S60QConversions::s60DescToQString(*description));     

    }

    // time stamp 

    TTime unixEpoch(KUnixEpoch);

    TTimeIntervalSeconds seconds;

    TTime timeStamp(entry.TimeStamp());

    timeStamp.SecondsFrom(unixEpoch, seconds);

    item.setData(seconds.Int(), TimeStamp);

    //contact details

    HBufC* contact = entry.Contact();

    if (contact && contact->Length()) {

        item.setData(S60QConversions::s60DescToQString(*contact), ConversationAddress);

    }

    // message type.

    int msgType = ConversationsEngineUtility::messageType(entry.GetType());

    item.setData(msgType, MessageType);

    //message sub-type

    item.setData(ConversationsEngineUtility::messageSubType(entry.GetType()), MessageSubType);

    // unread status

    if (entry.IsAttributeSet(ECsAttributeUnread)) {

        item.setData(true, UnReadStatus);

    }

    else {

        item.setData(false, UnReadStatus);

    }

    //sending state

    item.setData(entry.GetSendState(), SendingState);

    // direction

    item.setData(entry.ConversationDir(), Direction);

    //location

    if (entry.ConversationDir() == ECsDirectionIncoming) {

        item.setData(ConvergedMessage::Inbox, MessageLocation);

    }

    else if (entry.IsAttributeSet(ECsAttributeDraft)) {

        item.setData(ConvergedMessage::Draft, MessageLocation);

    }

    else if (entry.IsAttributeSet(ECsAttributeSent)) {

        item.setData(ConvergedMessage::Sent, MessageLocation);

    }

    else {

        item.setData(ConvergedMessage::Outbox, MessageLocation);

    }

    //message specific handling    

    if (msgType == ConvergedMessage::Mms) {

        QCRITICAL_WRITE("ConversationsModel::populateItem  MMS start.")

        handleMMS(item, entry);

        QCRITICAL_WRITE("ConversationsModel::populateItem MMS end.")

    }

    else if(msgType == ConvergedMessage::MmsNotification) {

        item.setData(subject, Subject);

        handleMMSNotification(item, entry);

    }

    else if (msgType == ConvergedMessage::BT) {

        handleBlueToothMessages(item, entry);

    }

    else if (msgType == ConvergedMessage::BioMsg) {

        handleBioMessages(item, entry);

    }

    else {

        // sms bodytext

        item.setData(subject, BodyText);

    }

    QCRITICAL_WRITE("ConversationsModel::populateItem end.");

}

//---------------------------------------------------------------

// ConversationsModel::handleMMS

// @see header

//---------------------------------------------------------------

void ConversationsModel::handleMMS(QStandardItem& item, const CCsConversationEntry& entry)

{

    //msg_id

    int msgId = entry.EntryId();

    bool isEntryInDb = false;

    TInt err = KErrNone;

    //check if db is open and query db

    if (iSqlDbOpen)

    {

        RSqlStatement sqlSelectStmt;

        err = sqlSelectStmt.Prepare(iSqlDb, KSelectConvMsgsStmt);

        // move to fallback option

        if (KErrNone == err)

            {

            TInt msgIdIndex = sqlSelectStmt.ParameterIndex(_L(":message_id"));

            TInt subjectIndex = sqlSelectStmt.ColumnIndex(_L("subject"));

            TInt bodyIndex = sqlSelectStmt.ColumnIndex(_L("body_text"));

            TInt previewPathIndex = sqlSelectStmt.ColumnIndex(

                    _L("preview_path"));

            TInt msgpropertyIndex = sqlSelectStmt.ColumnIndex(

            err = sqlSelectStmt.BindInt(msgIdIndex, msgId);

            // populate item

            if ((KErrNone == err) && (sqlSelectStmt.Next() == KSqlAtRow))

                {

                }

            }

        sqlSelectStmt.Close();

        }

    //fallback option incase of db operation failure or enry not found in DB

    //populate from data plugins

    if (!isEntryInDb || err != KErrNone)

    {

        iMmsDataPlugin->setMessageId(entry.EntryId());

        int msgProperty = 0;

        if (iMmsDataPlugin->attachmentCount() > 0)

        {

            msgProperty |= EPreviewAttachment;

        }

        //subject

        item.setData(iMmsDataPlugin->subject(), Subject);

        int slideCount = iMmsDataPlugin->slideCount();

        bool isBodyTextSet = false;

        bool isAudioSet = false;

        bool isImageSet = false;

        bool isVideoSet = false;

        QString textContent;

        QString videoPath;

        QString imagePath;

        for (int i = 0; i < slideCount; ++i)

        {

            UniMessageInfoList objectList = iMmsDataPlugin->slideContent(i);