/*

 * 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:  Manages differnt messaging views.

 *

 */

#include "msgserviceviewmanager.h"

#include <QFileInfo>

#include <QDir>

#include <QFile>

#include <QPixmap>

#include <HbMainWindow>

#include <HbAction>

#include <HbApplication>

#include <HbMessageBox>

#include <HbDeviceMessageBox>

#include <HbSplashScreen>

#include <xqserviceutil.h>

#include <xqappmgr.h>

#include <xqaiwdecl.h>

#include "msgunieditorview.h"

#include "unifiedviewer.h"

#include "msgstorehandler.h"

#include "msgsettingsview.h"

#include "convergedmessageid.h"

#include "ringbc.h"

#include "unidatamodelloader.h"

#include "unidatamodelplugininterface.h"

// CONSTANTS

static const char SEND_EFFECT[] = "sendeffect";

static const char SEND_EFFECT_FILE[] = ":/effects/sendeffect.fxml";

// LOCALIZATION

#define LOC_DELETED_MESSAGE hbTrId("txt_messages_dialog_message_has_been_deleted")

#define LOC_CANNOT_OPEN_MESSAGE hbTrId("txt_messages_dialog_message_is_outgoingcannot_be")

#define LOC_UNKNOWN_MSG_TYPE hbTrId("txt_messages_dialog_unsupported_message_type")

#define LOC_SAVE_RINGTONE hbTrId("txt_conversations_dialog_save_ringing_tone")

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

// MsgViewInterface::MsgViewInterface

// @see header

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

MsgServiceViewManager::MsgServiceViewManager(MsgStoreHandler* storeHandler,

        HbMainWindow* mainWindow, QObject* parent) :

        QObject(parent), mMainWindow(mainWindow), mUniEditor(NULL),

        mUniViewer(NULL), mSettingsView(NULL), mBackAction(NULL),

        mStoreHandler(storeHandler)

    {

    //creating back action.

    mBackAction = new HbAction(Hb::BackNaviAction, this);

    connect(mBackAction, SIGNAL(triggered()), this, SLOT(onBackAction()));

    // create a temp view : which is required for lazy loading of other views

    HbView* tempView = new HbView();

    mMainWindow->addView(tempView);

    mMainWindow->setCurrentView(tempView);

    }

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

// MsgServiceViewManager::~MsgServiceViewManager

// @see header

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

MsgServiceViewManager::~MsgServiceViewManager()

    {

    }

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

// MsgServiceViewManager::onBackAction

// @see header

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

void MsgServiceViewManager::onBackAction()

    {

    switch(mCurrentView)

        {

        case MsgBaseView::UNIEDITOR:

            {

            HbApplication::quit();

            break;

            }

        case MsgBaseView::MSGSETTINGS:

            {

            //delete the settings instance

            if (mSettingsView)

            {

                mMainWindow->removeView(mSettingsView);

                delete mSettingsView;

                mSettingsView = NULL;

            }

            if(mUniEditor)

                {

                mMainWindow->setCurrentView(mUniEditor);

                mCurrentView = MsgBaseView::UNIEDITOR;

                }

            else 

                {

                ConvergedMessage message;

                QVariantList param;

                QByteArray dataArray;

                QDataStream messageStream(&dataArray, 

                        QIODevice::WriteOnly | QIODevice::Append);

                message.serialize(messageStream);

                param << dataArray;

                // switch to editor

                switchToUniEditor(param);

                }

            break;

            }

        case MsgBaseView::UNIVIEWER: 

        default:

            {

            HbApplication::quit();

            break;

            }

        }

    }

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

// MsgServiceViewManager::switchView

// @see header

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

void MsgServiceViewManager::switchView(const QVariantList& data)

    {

    int viewId = data.at(0).toInt();

    switch (viewId)

        {

        case MsgBaseView::UNIEDITOR:

            {

            // except first 2 parameters pass other parameters

            QVariantList editorData;

            for(int a = 2; a < data.length(); ++a)

                {

                editorData << data.at(a);

                }

            switchToUniEditor(editorData);

            break;

            }

        case MsgBaseView::MSGSETTINGS:

            {

            switchToMsgSettings(data);

            break;

            }

        default: 

            {

            // if send from editor is successful, then run effects

            int previousView = data.at(1).toInt();

            if(previousView == MsgBaseView::UNIEDITOR)

                {

                startAnimation(SEND_EFFECT);

                }

            else

                {

                HbApplication::quit();

                }

            }

        }

    }

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

// MsgServiceViewManager::send

// @see header

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

void MsgServiceViewManager::send(const QString phoneNumber, 

        const qint32 contactId, 

        const QString displayName)

    {

    Q_UNUSED(contactId);

    mMainWindow->show();

    ConvergedMessage message;

    ConvergedMessageAddress address;

    address.setAddress(phoneNumber);

    address.setAlias(displayName);

    message.addToRecipient(address);

    QVariantList param;

    QByteArray dataArray;

    QDataStream messageStream(&dataArray, 

            QIODevice::WriteOnly | QIODevice::Append);

    message.serialize(messageStream);

    param << dataArray;

    // switch to editor

    switchToUniEditor(param);

    XQServiceUtil::toBackground(false);

    }

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

// MsgServiceViewManager::send

// @see header

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

void MsgServiceViewManager::send(const QString phoneNumber, 

        const QString alias, 

        const QString bodyText)

    {

    mMainWindow->show();

    ConvergedMessage message;

    ConvergedMessageAddress address;

    address.setAddress(phoneNumber);

    address.setAlias(alias);

    message.addToRecipient(address);

    message.setBodyText(bodyText);

    QVariantList param;

    QByteArray dataArray;

    QDataStream messageStream(&dataArray, 

            QIODevice::WriteOnly | QIODevice::Append);

    message.serialize(messageStream);

    param << dataArray;

    // switch to editor

    switchToUniEditor(param);

    XQServiceUtil::toBackground(false);

    }

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

// MsgServiceViewManager::send

// @see header

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

void MsgServiceViewManager::send(const QVariantMap addressList, 

              const QString bodyText)

    {

    mMainWindow->show();

    QStringList phoneNumList = addressList.keys(); 

    ConvergedMessageAddressList addrList;

    int count = phoneNumList.count();

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

        {

        QString phNum = phoneNumList[i];

        ConvergedMessageAddress* address = new ConvergedMessageAddress(phNum,

                addressList.value(phNum).toString());	

        addrList.append(address);

        }

    ConvergedMessage message;

    message.addToRecipients(addrList);

    message.setBodyText(bodyText);

    QVariantList param;

    QByteArray dataArray;

    QDataStream messageStream(&dataArray, 

            QIODevice::WriteOnly | QIODevice::Append);

    message.serialize(messageStream);

    param << dataArray;

    // switch to editor

    switchToUniEditor(param);

    XQServiceUtil::toBackground(false);

    }

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

// MsgServiceViewManager::send

// @see header

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

void MsgServiceViewManager::send(QVariant data)

    {

    mMainWindow->show();

    ConvergedMessage message;

    ConvergedMessageAttachmentList attachmentList;

    // handle multiple files from sendUI

    // e.g. contacts can send multiple vcards

    QStringList receivedFiles = data.toStringList();

    int recFileCount = receivedFiles.count();

    for (int i = 0; i < recFileCount; i++) {

    ConvergedMessageAttachment *attachment =

    new ConvergedMessageAttachment(receivedFiles.at(i));

    attachmentList.append(attachment);

    }

    message.addAttachments(attachmentList);

    QVariantList param;

    QByteArray dataArray;

    QDataStream messageStream(&dataArray, 

            QIODevice::WriteOnly | QIODevice::Append);

    message.serialize(messageStream);

    param << dataArray;

    // switch to editor

    switchToUniEditor(param);

    XQServiceUtil::toBackground(false);

    }

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

// MsgServiceViewManager::switchToUniEditor

// @see header

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

void MsgServiceViewManager::switchToUniEditor(const QVariantList& editorData)

{

    // construct

    if (!mUniEditor)

    {

        mUniEditor = new MsgUnifiedEditorView();

        mMainWindow->addView(mUniEditor);

        mUniEditor->setNavigationAction(mBackAction);

        connect(mUniEditor, SIGNAL(switchView(const QVariantList&)), this,

                SLOT(switchView(const QVariantList&)));

    }

    // populate

    mUniEditor->populateContent(editorData);

    // set current view as editor

    mMainWindow->setCurrentView(mUniEditor);

    mCurrentView = MsgBaseView::UNIEDITOR;

}

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

// MsgServiceViewManager::switchToMsgSettings

// @see header

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

void MsgServiceViewManager::switchToMsgSettings(const QVariantList& data)

{

    MsgSettingsView::SettingsView view = MsgSettingsView::DefaultView;

    if (mCurrentView == MsgBaseView::UNIEDITOR)

    {

        view = (MsgSettingsView::SettingsView)data.at(2).toInt();

    }

    mCurrentView = MsgBaseView::MSGSETTINGS;

    if (!mSettingsView)

    {        

        mSettingsView = new MsgSettingsView(view);

        mSettingsView->setNavigationAction(mBackAction);

        mMainWindow->addView(mSettingsView);

    }

    mMainWindow->setCurrentView(mSettingsView);

}

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

// MsgServiceViewManager::showPopup

// @see header

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

void MsgServiceViewManager::showPopup(const QString& dispText)

{

    HbDeviceMessageBox msgbox;

    msgbox.setMessageBoxType(HbMessageBox::MessageTypeInformation);

    msgbox.setText(dispText);

    msgbox.setAction(NULL, HbDeviceMessageBox::AcceptButtonRole);

    msgbox.exec();

    msgbox.close();

}

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

// MsgServiceViewManager::view

// @see header

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

void MsgServiceViewManager::view(int msgId)

{

    // Check if the message is present in store

    if(!mStoreHandler->exists(msgId))

    {

        showPopup(LOC_DELETED_MESSAGE);

        HbApplication::quit();

        return;

    }

    // Check if the given message is locked for viewing

    if(mStoreHandler->locked(msgId))

    {

        // if locked, then show info-note and exit

        showPopup(LOC_CANNOT_OPEN_MESSAGE);

        HbApplication::quit();

        return;

    }

    // Mark as read and get message type

    int msgType;

    int msgSubType;   

    mStoreHandler->markAsRead(msgId);

    mStoreHandler->getMsgTypeInfo(msgId,msgType,msgSubType);

    // Open draft message in editor

    if(mStoreHandler->isDraftMessage(msgId))

    {

        handleDraftMsg(msgId,msgType);

        return;

    }

    switch (msgType) 

    {

        case ConvergedMessage::Sms:

        case ConvergedMessage::Mms:

        {

            if (msgSubType == ConvergedMessage::VCard)

            {

                handleVCardMsg(msgId);

            }

            else

            {

                handleSmsMmsMsg(msgId);    

            }

            break;

        }

        case ConvergedMessage::MmsNotification:

        {

            handleMmsNotification(msgId);

            break;

        }

        case ConvergedMessage::BioMsg:

        {

            if (msgSubType == ConvergedMessage::RingingTone)

            {

                handleRingtoneMsg(msgId);

            }

            else if (msgSubType == ConvergedMessage::Provisioning)

            {

                handleProvisoningMsg(msgId);

            }

            else if (msgSubType == ConvergedMessage::VCard)

            {

                handleVCardMsg(msgId);

            }

            break;

        }

        case ConvergedMessage::BT:

        {

            handleBTMessage(msgId);

            break;

        }

        default:

        {

            // For all remaining unsupported messages, show delete option

            showPopup(LOC_UNKNOWN_MSG_TYPE);

            HbApplication::quit();

        }

    }

}

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

// MsgServiceViewManager::handleKeyEvent

// @see header

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

bool MsgServiceViewManager::handleKeyEvent(int key)

{

    MsgBaseView *baseView = static_cast<MsgBaseView *>(mMainWindow->currentView());

    bool eventHandled = false;

    if (baseView) {

        eventHandled = baseView->handleKeyEvent(key);

    }

    return eventHandled;

}

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

// MsgServiceViewManager::saveContentToDraft

// @see header

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

void MsgServiceViewManager::saveContentToDraft()

{

    if(mUniEditor)

    {

      mUniEditor->saveContentToDrafts();

    }

}

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

// MsgServiceViewManager::handleDraftMsg

// @see header

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

void MsgServiceViewManager::handleDraftMsg(int msgId, int msgType)

{

    // show the splash-screen

    // Note: This causes cancellation of view switching effects

//    HbSplashScreen::start();

    connect(mMainWindow, SIGNAL(viewReady()), this, SLOT(showOnViewReady()));

    mCurrentView = MsgBaseView::UNIEDITOR;

    // construct editor instance (keep it minimal)

    if (!mUniEditor)

    {

        mUniEditor = new MsgUnifiedEditorView();

        mMainWindow->addView(mUniEditor);

        mUniEditor->setNavigationAction(mBackAction);

        connect(mUniEditor, SIGNAL(switchView(const QVariantList&)), this,

                SLOT(switchView(const QVariantList&)));

    }

    // prepare data for unieditor

    ConvergedMessage message;

    ConvergedMessageId convergedMsgId = ConvergedMessageId(msgId);

    message.setMessageType((ConvergedMessage::MessageType) msgType);

    message.setMessageId(convergedMsgId);

    QByteArray dataArray;

    QDataStream messageStream(&dataArray, QIODevice::WriteOnly | QIODevice::Append);

    message.serialize(messageStream);

    QVariantList editorData;

    editorData << dataArray;

    mMainWindow->show();

    // populate data into editor