/*

 * 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 <ccsconversationentry.h>

#include <QFile>

// LOCAL CONSTANTS

const QString MMSStr("mms");

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

// ConversationsModel::ConversationsModel

// Constructor

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

ConversationsModel::ConversationsModel(

    ConversationMsgStoreHandler* msgStoreHandler,

    QObject* parent): QStandardItemModel(parent),

    mMsgStoreHandler(msgStoreHandler)

            {

            iDataModelPluginLoader = new UniDataModelLoader;

            iDataModelPluginLoader->loadPlugins();

            iMmsDataPlugin = iDataModelPluginLoader->getDataModelPlugin(MMSStr);

            }

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

// ConversationsModel::~ConversationsModel

// Destructor

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

ConversationsModel::~ConversationsModel()

    {

    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 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 FirstName: // Fall through start

            value = item->data(FirstName);

            break;

        case LastName:

            value = item->data(LastName);

            break;

        case NickName:

            value = item->data(NickName);

            break;

        case Avatar:    // Fall througn end

            value = item->data(Avatar);

            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)

    {

    int msgId = entry.EntryId();

    // id

    item.setData(msgId, ConvergedMsgId);

    // description

    HBufC* description = entry.Description();

    QString subject("");

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

        {

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

        item.setData(subject, Subject); 

        }

    // 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.

    item.setData(ConversationsEngineUtility::messageType(entry.GetType()), MessageType);

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

    TCsType msgType = entry.GetType();

    if(msgType == ECsMMS)

    {

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

        if( iMmsDataPlugin->attachmentCount() > 0 )

        {

        item.setData(ConvergedMessage::Attachment,MessageProperty);

        }

        int slideCount = iMmsDataPlugin->slideCount();

        bool isBodyTextSet = false;

        QString textContent;

        QStringList attachmentPaths;

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

        {

            UniMessageInfoList objectList = iMmsDataPlugin->slideContent(i);

            for( int index=0; index < objectList.count() ; ++index )

            {

                attachmentPaths.append(objectList[index]->path());

                if( !isBodyTextSet && objectList[index]->mimetype().contains("text") )

                {

                    QFile file(objectList[index]->path());

                    file.open(QIODevice::ReadOnly);

                    textContent = file.readAll();

                    item.setData(textContent, BodyText);

                    isBodyTextSet = true;

                    file.close();

                }

            }

            foreach(UniMessageInfo* slide,objectList)

                {

                delete slide;

                }

        }

        //populate item  with the attachment list

        item.setData(attachmentPaths.join("|"),Attachments);

        if(entry.IsAttributeSet(ECsAttributeHighPriority))

        {

            item.setData(ConvergedMessage::High,MessagePriority);

        }

        else if(entry.IsAttributeSet(ECsAttributeLowPriority))

        {

            item.setData(ConvergedMessage::Low,MessagePriority);

        }

    }

    else

    {

        // sms bodytext

        item.setData(subject, BodyText);

    }

    //presence

    //TODO

    }

//EOF