/*

 * 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:Conversation (chat) view for messaging application.

 *

 */

#include "msgconversationview.h"

// SYSTEM INCLUDES

#include <HbMenu>

#include <HbAction>

#include <HbListView>

#include <HbMessageBox>

#include <HbNotificationDialog>

#include <HbFrameBackground>

#include <xqservicerequest.h>

#include <HbStaticVkbHost>

#include <HbStyleLoader>

#include <xqaiwrequest.h>

#include <xqappmgr.h>

#include <HbMainWindow>

#include <QDir>

#include <QDateTime>

#include <QGraphicsLinearLayout>

#include <QStandardItemModel>

#include <cntservicescontact.h>

#include <ccsdefs.h>

#include <centralrepository.h>

#include <MmsEngineDomainCRKeys.h>

// USER INCLUDES

#include "msgcontactsutil.h"

#include "msgsendutil.h"

#include "msgconversationviewitem.h"

#include "conversationsengine.h"

#include "convergedmessageid.h"

#include "conversationsenginedefines.h"

#include "msgcontactcardwidget.h"

#include "msgeditorwidget.h"

#include "msgviewdefines.h"

#include "debugtraces.h"

#include "unidatamodelloader.h"

#include "unidatamodelplugininterface.h"

#include "ringbc.h"

#include "mmsconformancecheck.h"

#include "msgsettingsview.h"

#include "msgaudiofetcherview.h"

//Item specific menu.

#define LOC_COMMON_OPEN hbTrId("txt_common_menu_open")

#define LOC_COMMON_DELETE hbTrId("txt_common_menu_delete")

#define LOC_COMMON_FORWARD hbTrId("txt_common_menu_forward")

#define LOC_COMMON_DOWNLOAD hbTrId("txt_messaging_menu_download")

#define LOC_COMMON_SEND  hbTrId("txt_common_button_send") 

#define LOC_COMMON_SAVE  hbTrId("txt_common_menu_save")

#define LOC_DELETE_MESSAGE hbTrId("txt_messaging_dialog_delete_message")

#define LOC_SAVE_TO_CONTACTS hbTrId("txt_messaging_menu_save_to_contacts")

//main menu

#define LOC_ATTACH          hbTrId("txt_messaging_opt_attach")

#define LOC_PHOTO           hbTrId("txt_messaging_opt_attach_sub_photo")

#define LOC_SOUND           hbTrId("txt_messaging_opt_attach_sub_sound")

#define LOC_VCARD           hbTrId("txt_messaging_list_business_card")

#define LOC_ADD_RECIPIENTS  hbTrId("txt_messaging_opt_add_recipients")

#define LOC_ADD_SUBJECT     hbTrId("txt_messaging_opt_add_subject")

#define LOC_MSG_SEND_FAILED hbTrId("txt_messaging_dialog_message_sending_failed")

#define LOC_DIALOG_SMS_SETTINGS_INCOMPLETE hbTrId("txt_messaging_dialog_sms_settings_incomplete")

#define LOC_DIALOG_SAVE_RINGTONE hbTrId("txt_conversations_dialog_save_ringing_tone")

const int INVALID_MSGID = -1;

const int INVALID_CONVID = -1;

const int CONTACT_INSERTION_MODE = 1;

const int VCARD_INSERTION_MODE = 0;

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

// MsgConversationView::MsgConversationView

// @see header file

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

MsgConversationView::MsgConversationView(MsgContactCardWidget *contactCardWidget,

    QGraphicsItem *parent) :

    MsgBaseView(parent),

    mConversationList(NULL),

    mMessageModel(NULL),

    mEditorWidget(NULL),

    mContactCardWidget(contactCardWidget),

    mSendUtil(NULL),

    mVkbHost(NULL),

    mVisibleIndex(),

    mVkbopened(false),

    mModelPopulated(false),

    mViewReady(false)

{

    //create send utils

    mSendUtil = new MsgSendUtil(this);

    //initialize view

    setupView();

    setupMenu();

    connect(ConversationsEngine::instance(), 

                     SIGNAL(conversationModelUpdated()),

                     this, 

                     SLOT(scrollToBottom()));

    connect(ConversationsEngine::instance(), 

                         SIGNAL(conversationViewEmpty()),

                         this, 

                         SLOT(onConversationViewEmpty()));

}

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

// MsgConversationView::~MsgConversationView

// @see header file

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

MsgConversationView::~MsgConversationView()

{

}

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

// MsgConversationView::setupView

// @see header file

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

void MsgConversationView::setupView()

{

    // Create HbListView and set properties

    mConversationList = new HbListView();

    if (!HbStyleLoader::registerFilePath(":/layouts")) {

        QDEBUG_WRITE("ERROR: ConversationView -> HbStyleLoader::registerFilePath");

    }

    mConversationList->setLayoutName("custom");

    mConversationList->setItemRecycling(true);

    MsgConversationViewItem *item = new MsgConversationViewItem(this);

    HbFrameBackground defaultBackground;

    defaultBackground.setFrameGraphicsName(QString(""));

    item->setDefaultFrame(defaultBackground);

    mConversationList->setItemPrototype(item);

    mConversationList->setSelectionMode(HbListView::NoSelection);

    mConversationList->setClampingStyle(HbScrollArea::BounceBackClamping);

    mConversationList->setScrollingStyle(HbScrollArea::PanOrFlick);

    mMessageModel = ConversationsEngine::instance()->getConversationsModel();

    connect(ConversationsEngine::instance(), 

            SIGNAL(conversationModelPopulated()), 

            this, 

            SLOT(populateConversationsView()));

    connect(mConversationList, SIGNAL(activated(QModelIndex)),

            this, SLOT(openItem(QModelIndex)));

    connect(this->mainWindow(), SIGNAL(aboutToChangeOrientation()),

                this, SLOT(onOrientationAboutToBeChanged()));

    connect(this->mainWindow(), SIGNAL(orientationChanged(Qt::Orientation)),

                    this, SLOT(onOrientationChanged(Qt::Orientation)));

    // Long tap list item

    connect(mConversationList, SIGNAL(longPressed(HbAbstractViewItem*, QPointF)),

            this, SLOT(longPressed(HbAbstractViewItem*, QPointF)));

    // Create message editor widget, will be displayed based on msg type.

    mEditorWidget = new MsgEditorWidget(this);

    mEditorWidget->hide();

    connect(mEditorWidget, SIGNAL(sendMessage()), this, SLOT(send()));

    connect(mEditorWidget, SIGNAL(smsCharLimitReached()), 

        this, SLOT(handleSmsCharLimitReached()));

    connect(mEditorWidget, SIGNAL(replyStarted()), this, SIGNAL(replyStarted()));

    qreal spacing = HbDeviceProfile::profile(mConversationList).unitValue();

    mMainLayout = new QGraphicsLinearLayout(Qt::Vertical,this); 

    mMainLayout->setContentsMargins(CONTENT_MARGIN, CONTENT_MARGIN,

                                    CONTENT_MARGIN, CONTENT_MARGIN);   

    mMainLayout->setSpacing(spacing);

    mMainLayout->addItem(mConversationList);

    setLayout(mMainLayout);

    //Create VKB instance and listen to VKB open and close signals for resizing the view.

    mVkbHost = new HbStaticVkbHost(this);

	connect(mVkbHost, SIGNAL(keypadOpened()), this, SLOT(vkbOpened()));

	connect(mVkbHost, SIGNAL(keypadClosed()), this, SLOT(vkbClosed()));

    // Refresh view to show the header details

    refreshView();

}

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

// MsgConversationView::addMenu

// @see header file

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

void MsgConversationView::setupMenu()

{

    // Just create dummy menu.

    // Actual menu will be created in menuAboutToShow()

    HbMenu *mainMenu = this->menu();

    HbAction* clearConversation = mainMenu->addAction(QString());

    connect(mainMenu, SIGNAL(aboutToShow()), this, SLOT(menuAboutToShow()));

}

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

// MsgConversationView::fetchMoreConversations

// @see header file

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

void MsgConversationView::fetchMoreConversations()

{

    if (mViewReady && mModelPopulated) {

        ConversationsEngine::instance()->fetchMoreConversations();

        mViewReady = mModelPopulated = false;

    }

}

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

// MsgConversationView::refreshView()

// @see header file

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

void MsgConversationView::refreshView()

{

    // Hide editor in case of BT conversations.

    qint64 convId = ConversationsEngine::instance()->getCurrentConversationId();

    if (INVALID_CONVID != convId) {

        if (KBluetoothMsgsConversationId == convId) {

            mMainLayout->removeItem(mEditorWidget);

            mEditorWidget->hide();

            mEditorWidget->setParent(this);

        }

        else {

            mMainLayout->addItem(mEditorWidget);

            TRAP_IGNORE(mEditorWidget->setEncodingSettingsL());

            mEditorWidget->show();

        }

        mContactCardWidget->updateContents();

    }

}

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

// MsgConversationView::scrollToBottom()

// @see header file

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

void MsgConversationView::scrollToBottom()

{

    const int rowCnt = mMessageModel->rowCount();

    mConversationList->scrollTo(

            mMessageModel->index(rowCnt - 1, 0));

}

void MsgConversationView::onConversationViewEmpty()

{

    QVariantList param;

    param << MsgBaseView::CLV; // target view

    param << MsgBaseView::CV; // source view

    emit switchView(param);

}

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

// MsgConversationView::longPressed

// @see header file

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

void MsgConversationView::longPressed(HbAbstractViewItem* viewItem,

    const QPointF& point)

{    

    MsgConversationViewItem* item = qgraphicsitem_cast<

            MsgConversationViewItem *> (viewItem);

    // Show the item-specific menu

    if (this->isVisible())

    {

        //If message is in Sending state or is Scheduled to be sent later,

        //do not allow any operations on the message

        int sendingState = item->modelIndex().data(SendingState).toInt();

        if(sendingState == ConvergedMessage::Scheduled ||

                   sendingState == ConvergedMessage::Sending ||

                   sendingState == ConvergedMessage::Waiting)

           {

               return;

           }

        // Create new menu

        HbMenu* contextMenu = new HbMenu();

        contextMenu->setAttribute(Qt::WA_DeleteOnClose);

        contextMenu->setPreferredPos(point);

        setContextMenu(item, contextMenu, sendingState);

        contextMenu->show();

    }

}

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

// MsgConversationView::setContextMenu

// @see header

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

void MsgConversationView::setContextMenu(MsgConversationViewItem* item, HbMenu* contextMenu, int sendingState)

{

    addOpenItemToContextMenu(item , contextMenu,sendingState);

    addResendItemToContextMenu(item, contextMenu, sendingState);

    addForwardItemToContextMenu(item, contextMenu, sendingState);

    addDownloadItemToContextMenu(item, contextMenu);

    addDeleteItemToContextMenu(item, contextMenu, sendingState);

    addSaveItemToContextMenu(item , contextMenu,sendingState);

}

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

// MsgEditorPrivate::addSaveItemToContextMenu

// @see header

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

void MsgConversationView::addSaveItemToContextMenu(MsgConversationViewItem* item,

    HbMenu* contextMenu, int sendingState)

{

    Q_UNUSED(sendingState)

    int messageSubType = item->modelIndex().data(MessageSubType).toInt();

    int direction =  item->modelIndex().data(Direction).toInt();

    if ((messageSubType == ConvergedMessage::RingingTone) && 

        (direction == ConvergedMessage::Incoming)) {

        HbAction *contextItem = contextMenu->addAction(LOC_COMMON_SAVE);

        connect(contextItem, SIGNAL(triggered()), this, SLOT(saveRingingTone()));

    }

}

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

// MsgEditorPrivate::addOpenItemToContextMenu

// @see header

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

void MsgConversationView::addOpenItemToContextMenu(MsgConversationViewItem* item, HbMenu* contextMenu, int sendingState)

{

    int direction = item->modelIndex().data(Direction).toInt();

    int messageType = item->modelIndex().data(MessageType).toInt();

    int messageSubType = item->modelIndex().data(MessageSubType).toInt();

    if((messageSubType == ConvergedMessage::VCal) ||

        (messageSubType == ConvergedMessage::RingingTone) ||

        (messageType == ConvergedMessage::MmsNotification))

        {

        return;

        }

    if ((messageSubType == ConvergedMessage::VCard) &&

        (direction == ConvergedMessage::Incoming))

        {

        HbAction *contextItem = contextMenu->addAction(LOC_SAVE_TO_CONTACTS);

        connect(contextItem, SIGNAL(triggered()),this, SLOT(openItem()));

        return;

        }

    if( (sendingState == ConvergedMessage::SentState ) ||

        (direction == ConvergedMessage::Incoming))

    {

        HbAction *contextItem = contextMenu->addAction(LOC_COMMON_OPEN);

        connect(contextItem, SIGNAL(triggered()),this, SLOT(openItem()));

    }

}

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

// MsgEditorPrivate::addResendItemToContextMenu

// @see header

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

void MsgConversationView::addResendItemToContextMenu(MsgConversationViewItem* item, HbMenu* contextMenu, int sendingState)

{

    Q_UNUSED(item)

    int direction = item->modelIndex().data(Direction).toInt();

    if( (direction == ConvergedMessage::Outgoing)&&

        ((sendingState == ConvergedMessage::Resend ) ||

        (sendingState == ConvergedMessage::Suspended )||

        (sendingState == ConvergedMessage::Failed )))

    {

        HbAction *contextItem = contextMenu->addAction(LOC_COMMON_SEND);

        connect(contextItem, SIGNAL(triggered()),this, SLOT(resendMessage()));

    }

}

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

// MsgEditorPrivate::addForwardItemToContextMenu

// @see header

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

void MsgConversationView::addForwardItemToContextMenu(MsgConversationViewItem* item, HbMenu* contextMenu, int sendingState)

{

    int messageType = item->modelIndex().data(MessageType).toInt();

    int direction = item->modelIndex().data(Direction).toInt();

    int messageSubType = item->modelIndex().data(MessageSubType).toInt();

    if( (messageType == ConvergedMessage::BT) ||

        (messageType == ConvergedMessage::MmsNotification) ||

        (messageSubType == ConvergedMessage::Provisioning ) ||

        (messageSubType == ConvergedMessage::RingingTone) ||

        (messageSubType == ConvergedMessage::VCal))

    {

        return;

    }

    qint32 messageId = item->modelIndex().data(ConvergedMsgId).toInt();

    qint32 messageProperty = item->modelIndex().data(MessageProperty).toInt();

    bool canForwardMessage  = true;

    if (messageType == ConvergedMessage::Mms){

        canForwardMessage = (messageProperty & EPreviewForward)? true:false;

    }            

    if( ((sendingState == ConvergedMessage::SentState) ||

        (sendingState == ConvergedMessage::Resend) ||

        (sendingState == ConvergedMessage::Failed) ||

        (direction == ConvergedMessage::Incoming) ) &&

        canForwardMessage)

    {

        HbAction *contextItem = contextMenu->addAction(LOC_COMMON_FORWARD);

        connect(contextItem, SIGNAL(triggered()),this, SLOT(forwardMessage()));

    }

}

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

// MsgEditorPrivate::addDeleteItemToContextMenu

// @see header

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

void MsgConversationView::addDeleteItemToContextMenu(MsgConversationViewItem* item, HbMenu* contextMenu, int sendingState)

{

    int direction = item->modelIndex().data(Direction).toInt();

    int messageType = item->modelIndex().data(MessageType).toInt();

    int notificationState = item->modelIndex().data(NotificationStatus).toInt();

    if( (messageType == ConvergedMessage::MmsNotification) && 

        ((notificationState == ConvergedMessage::NotifNull) || 

         (notificationState ==  ConvergedMessage::NotifRetrieving) ||

         (notificationState == ConvergedMessage::NotifWaiting)))

    {

        return;

    }

    if( (sendingState == ConvergedMessage::SentState) ||

        (sendingState == ConvergedMessage::Resend) ||

        (sendingState == ConvergedMessage::Suspended) ||

        (sendingState == ConvergedMessage::Failed) ||

        (direction == ConvergedMessage::Incoming))

    {

        HbAction *contextItem = contextMenu->addAction(LOC_COMMON_DELETE);

        connect(contextItem, SIGNAL(triggered()),this, SLOT(deleteItem()));

    }  

}

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

// MsgEditorPrivate::addDownloadItemToContextMenu

// @see header

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

void MsgConversationView::addDownloadItemToContextMenu(MsgConversationViewItem* item, HbMenu* contextMenu)

{

    int notificationState = item->modelIndex().data(NotificationStatus).toInt();

    int messageType = item->modelIndex().data(MessageType).toInt();

    qint32 messageId = item->modelIndex().data(ConvergedMsgId).toLongLong();

    if( messageType == ConvergedMessage::MmsNotification &&

        ConversationsEngine::instance()->downloadOperationSupported(messageId))

    {            

        HbAction *contextItem = contextMenu->addAction(LOC_COMMON_DOWNLOAD);

        connect(contextItem, SIGNAL(triggered()),this, SLOT(downloadMessage()));

    }

}

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

// MsgEditorPrivate::send

// @see header

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

void MsgConversationView::send()

{

    activateInputBlocker();

    ConvergedMessageAddressList addresses;

    addresses = mContactCardWidget->address();

    int sendResult = KErrNone;

    // Populate the ConvergedMessage.

    if (!addresses.isEmpty())

    {

        ConvergedMessage msg;

        populateForSending(msg);

        msg.addToRecipients(addresses);

        // Send

        sendResult = mSendUtil->send(msg);

        if( sendResult == KErrNone)

        {

            mEditorWidget->clear();

        }

    }

    deactivateInputBlocker();

    if( sendResult == KErrNotFound)

    {

    HbMessageBox::question(LOC_DIALOG_SMS_SETTINGS_INCOMPLETE, this,

                           SLOT(onDialogSettingsLaunch(HbAction*)), 

                           HbMessageBox::Ok | HbMessageBox::Cancel);

    }

}

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

// MsgConversationView::contactsFetchedForVCards

// @see header file

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

void MsgConversationView::contactsFetchedForVCards(const QVariant& value)

{

    // get received contact-list and launch unieditor

    CntServicesContactList contactList = 

            qVariantValue<CntServicesContactList>(value);