/*

 * 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: Mail viewer implementation.

 *

 */

#include "nmuiheaders.h"

static const char *NMUI_MESSAGE_VIEWER_XML = ":/docml/nmmailviewer.docml";

static const char *NMUI_MESSAGE_VIEWER_VIEW = "nmailViewerView";

static const char *NMUI_MESSAGE_VIEWER_CONTENT = "content";

static const char *NMUI_MESSAGE_VIEWER_SCROLL_AREA = "viewerScrollArea";

static const char *NMUI_MESSAGE_VIEWER_SCROLL_AREA_CONTENTS = "viewerScrollAreaContents";

static const char *NMUI_MESSAGE_VIEWER_HEADER = "viewerHeader";

static const char *NMUI_MESSAGE_VIEWER_ATTALIST = "viewerAttaList";

static const char *NMUI_MESSAGE_VIEWER_SCROLL_WEB_VIEW = "viewerWebView";

static const int NmOrientationTimer = 100;

static const int NmHeaderMargin = 3;

static const int NmWhitePixmapSize = 10;

static const int NmProgressValueComplete = 100;

static const QString NmParamTextHeightSecondary = "hb-param-text-height-secondary";

static const QString NmHttpLinkScheme = "http";

static const QString NmHttpsLinkScheme = "https";

static const QString NmMailtoLinkScheme = "mailto";

// Local constants

const qreal NmZoomFactor = 1.5;

/*!

	\class NmViewerView

	\brief Mail viewer class

*/

/*!

    Constructor

*/

NmViewerView::NmViewerView(

    NmApplication &application,

    NmUiStartParam* startParam,

    NmUiEngine &uiEngine,

    HbMainWindow *mainWindow,

    NmAttachmentManager &attaManager,

    bool toolbarEnabled,

    QGraphicsItem *parent)

:NmBaseView(startParam, application, parent),

mApplication(application),

mUiEngine(uiEngine),

mMainWindow(mainWindow),

mAttaManager(attaManager),

mToolbarEnabled(toolbarEnabled),

mMessage(NULL),

mScrollArea(NULL),

mViewerContent(NULL),

mWebView(NULL),

mHeaderWidget(NULL),

mMessageFetchingOperation(NULL),

mDisplayingPlainText(false),

mDocumentLoader(NULL),

mScrollAreaContents(NULL),

mScreenSize(QSize(0,0)),

mWaitDialog(NULL),

webFrameloadingCompleted(false),

mLatestLoadingSize(QSize(0,0)),

mAttaIndexUnderFetch(NmNotFoundError),

mAttaWidget(NULL),

mViewReady(false),

mWaitNoteCancelled(false),

mErrorNote(NULL)

{

    // Create documentloader

    mDocumentLoader = new NmUiDocumentLoader(mMainWindow);

    // Get screensize

    mScreenSize = mApplication.screenSize();

    // Connect external delete handling to uiengine signal

    connect(&mUiEngine,

            SIGNAL(messageDeleted(const NmId &, const NmId &, const NmId &)),

            this, SLOT(messageDeleted(const NmId &, const NmId &, const NmId &)),

            Qt::UniqueConnection);

    // Fetch message

    loadMessage();

    // Load view layout

    loadViewLayout();

}

/*!

    Destructor

*/

NmViewerView::~NmViewerView()

{

    delete mErrorNote;

    mErrorNote=NULL;

    delete mWebView;

    mWebView = NULL;

    delete mMessage;

    mMessage = NULL;

    delete mDocumentLoader;

    mDocumentLoader = NULL;

    mWidgetList.clear();

    delete mWaitDialog;

    mWaitDialog = NULL;

    // remove view from osbserving atta manager events

    mAttaManager.clearObserver();

    mAttaManager.cancelFetch();

}

/*!

    View is about to exit

*/

void NmViewerView::aboutToExitView()

{

    // View is about to exit, for safety, stop 

    // loading of content before closing the view

    if (mWebView){

        mAttaManager.cancelFetch();

        mWebView->stop();

        if (mWebView->page()){

            mWebView->page()->deleteLater();

        }

    }

}

/*!

    View layout loading from XML

*/

void NmViewerView::loadViewLayout()

{

    NM_FUNCTION;

    // Use document loader to load the view

    bool ok(false);

    setObjectName(QString(NMUI_MESSAGE_VIEWER_VIEW));

   QObjectList objectList;

   objectList.append(this);

   // Pass the view to documentloader. Document loader uses this view

   // when docml is parsed, instead of creating new view.

   // documentloader is created in constructor

   mDocumentLoader->setObjectTree(objectList);

   mWidgetList = mDocumentLoader->load(NMUI_MESSAGE_VIEWER_XML, &ok);

   if (ok)

   {

        // Create content and content layout

        // qobject_cast not work in this case, using reinterpret_cast

        mViewerContent = reinterpret_cast<HbWidget *>(

                mDocumentLoader->findObject(NMUI_MESSAGE_VIEWER_CONTENT));

        // Find scroll area

        mScrollArea = reinterpret_cast<HbScrollArea *>(

                mDocumentLoader->findObject(NMUI_MESSAGE_VIEWER_SCROLL_AREA));

        if (mScrollArea) {

            mScrollArea->setParentItem(this);

            mScrollArea->setScrollDirections(Qt::Vertical | Qt::Horizontal);

            connect(mScrollArea, SIGNAL(scrollPositionChanged(QPointF)),

                this, SLOT(contentScrollPositionChanged(QPointF)));

            // Get scroll area contents and set layout margins

            mScrollAreaContents = qobject_cast<HbWidget *>(

                    mDocumentLoader->findObject(NMUI_MESSAGE_VIEWER_SCROLL_AREA_CONTENTS));

            if (mScrollAreaContents) {

                QGraphicsLayout *layout = mScrollAreaContents->layout();

                if (layout){

                    layout->setContentsMargins(0,0,0,0);

                }

                // Set white pixmap to backgrounditem 

                QPixmap whitePixmap(NmWhitePixmapSize,NmWhitePixmapSize);

                whitePixmap.fill(Qt::white);

                QGraphicsPixmapItem *pixmapItem = new QGraphicsPixmapItem(whitePixmap);

                mScrollAreaContents->setBackgroundItem(pixmapItem);

            }

            // Load headerwidget

            mHeaderWidget = qobject_cast<NmViewerHeader *>(

                    mDocumentLoader->findObject(NMUI_MESSAGE_VIEWER_HEADER));

            if (mHeaderWidget) {

                mHeaderWidget->setView(this);

                mHeaderWidget->rescaleHeader(mScreenSize);

                mHeaderWidget->setMessage(mMessage);

                QPointF headerStartPos = mHeaderWidget->scenePos();

                mHeaderStartScenePos = QPointF(0,headerStartPos.y());

            }

            // Load webview

            mWebView = reinterpret_cast<NmMailViewerWK *>(

                    mDocumentLoader->findObject(QString(NMUI_MESSAGE_VIEWER_SCROLL_WEB_VIEW)));

            if (mWebView) {

                // Set auto load images and private browsing(no history) attributes

                QWebSettings *settings = mWebView->settings();

                if (settings) {

                    settings->setAttribute(QWebSettings::AutoLoadImages, true);

                    settings->setAttribute(QWebSettings::PrivateBrowsingEnabled, true);

                }

                QWebPage *page = mWebView->page();

                if (page) {

                    QWebFrame *frame = page->mainFrame();

                    if (frame) {

                        frame->setScrollBarPolicy(Qt::Vertical,Qt::ScrollBarAlwaysOff);

                        frame->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);

                        frame->setTextSizeMultiplier(NmZoomFactor);

                        connect(mWebView->page()->mainFrame(),

                                SIGNAL(contentsSizeChanged(const QSize&)),

                            this, SLOT(scaleWebViewWhenLoading(const QSize&)));  

                    }

                }

            }

        }

    }

}

/*!

    Lazy loading when view layout has been loaded

*/

void NmViewerView::viewReady()

{

    if (!mViewReady){

        // Set mailbox name to title

        setMailboxName();

        // Create toolbar if needed

        if (mToolbarEnabled) {

            createToolBar();

        } else {

            // Connect options menu about to show to create options menu function

            QObject::connect(menu(), SIGNAL(aboutToShow()),

                    this, SLOT(createOptionsMenu())); 

            // Menu needs one dummy item so that aboutToShow signal is emitted.

            NmAction *dummy = new NmAction(0);

            menu()->addAction(dummy);

        }

        if (mHeaderWidget) {

            QPointF contentWidgetPos = mScrollArea->pos();

            qreal headerHeight = mHeaderWidget->geometry().height();

            if (mMainWindow->orientation() == Qt::Horizontal) {

                const QPointF pointToWebView(contentWidgetPos.x(), headerHeight+NmHeaderMargin);

                mScrollArea->scrollContentsTo(pointToWebView,0);

            }

        }

        // Run fetchmessage in queue

        QMetaObject::invokeMethod(this, "fetchMessage", Qt::QueuedConnection);

        // Set view ready

        mViewReady = true;

    }

}

/*!

    Function fecthes message data based on parameters

*/

void NmViewerView::loadMessage()

{

    NM_FUNCTION;

    if (mMessage) {

        delete mMessage;

        mMessage = NULL;

    }

    // Read start params and message object

    if (mStartParam){

        NmId mailboxId = mStartParam->mailboxId();

        NmId folderId = mStartParam->folderId();

        NmId msgId = mStartParam->messageId();

        mMessage = mUiEngine.message(mailboxId, folderId, msgId);

    }

}

/*!

    Function fecthes message data based on parameters. Returns false if message is available,

    true if message have to be fetched

*/

void NmViewerView::fetchMessage()

{

    NM_FUNCTION;

    if (mMessage) {

        NmId mailboxId = mStartParam->mailboxId();

        NmId folderId = mStartParam->folderId();

        NmId msgId = mStartParam->messageId();

        const NmMessagePart *body = mMessage->htmlBodyPart();

        if (!body) {

            // try plain to plain text part

            body = mMessage->plainTextBodyPart();

        }

        // try to fetch if body missing or fetched size is smaller than content size

        // if body missing it might mean that only header is fetched or message has no body

        if (!body || (body && (body->fetchedSize() < body->size()))) {

            // start fetching operation

            if (mMessageFetchingOperation && mMessageFetchingOperation->isRunning()) { 

                mMessageFetchingOperation->cancelOperation();

            }

            mMessageFetchingOperation = mUiEngine.fetchMessage(mailboxId, folderId, msgId);

            if (mMessageFetchingOperation) {

                connect(mMessageFetchingOperation,

                        SIGNAL(operationCompleted(int)),

                        this,

                        SLOT(messageFetched(int)));

                createAndShowWaitDialog();

            }

        } else {

            // message is fetched

            setMessageData();

        }

    }

}

/*!

    This is signalled by mMessageFetchingOperation when the original message is fetched.

 */

void NmViewerView::messageFetched(int result)

{

    mWaitDialog->close();

    disconnect(mWaitDialog->mainWindow(), SIGNAL(orientationChanged(Qt::Orientation)),

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

    if (result == NmNoError && mMessageFetchingOperation) {

        if (mMessage) {

            delete mMessage;

            mMessage = NULL;

        }

        // Read start params and message object

        if (mStartParam) {

            NmId mailboxId = mStartParam->mailboxId();

            NmId folderId = mStartParam->folderId();

            NmId msgId = mStartParam->messageId();

            mMessage = mUiEngine.message(mailboxId, folderId, msgId);

        }

        setMessageData();

        // Update header message data

		if (mHeaderWidget){

        	mHeaderWidget->updateMessageData(mMessage);

		}

    }

}

/*!

    This is signalled by mWaitDialog when the note is cancelled

 */

void NmViewerView::waitNoteCancelled()

{

    if (!mWaitNoteCancelled) {

        if (mMessageFetchingOperation && mMessageFetchingOperation->isRunning()) { 

	        mMessageFetchingOperation->cancelOperation();

        }

        mWaitNoteCancelled = true;

        QMetaObject::invokeMethod(&mApplication, "prepareForPopView", Qt::QueuedConnection);

    }

}

/*!

    Function sets message data to web view and header

*/

void NmViewerView::setMessageData()

{

    NM_FUNCTION;

    // Connect to observe orientation change events

    connect(mApplication.mainWindow(), SIGNAL(orientationChanged(Qt::Orientation)),

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

    // Set page parameters

    QWebPage *page(NULL);

    if (mWebView){

       page = mWebView->page();

    }

    if (page){

        // Set custom network access manager for embedded image handling

        NmViewerViewNetManager &netMngr = mApplication.networkAccessManager();

        netMngr.setView(this);

        page->setNetworkAccessManager(&netMngr);

        QWebSettings *webSettings = page->settings();

        if (webSettings) {

            webSettings->setObjectCacheCapacities(0,0,0);

        }

        connect(page, SIGNAL(loadFinished(bool)),

                    this, SLOT(webFrameLoaded(bool)));

        page->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);

        page->setContentEditable(false);

    }

  	// if everything is ok, set message to html viewer

    if (mMessage && mWebView && page) {

        // Set initial size of component and content before loading data

        mWebView->setPreferredWidth(mScreenSize.width());

        QRectF myGeometry = geometry();

        page->setViewportSize(myGeometry.size().toSize());

        //Set message data to html viewer.

        mWebView->setHtml(formatMessage());

        // Connect to link clicked

        QObject::connect(page, SIGNAL(linkClicked(const QUrl&)),

                this, SLOT(linkClicked(const QUrl&)));

        changeMessageReadStatus(true);

        setAttachmentList();

    }

}

/*!

*/

void NmViewerView::setAttachmentList()

{

    NM_FUNCTION;

    // Load headerwidget

    mAttaWidget = qobject_cast<NmAttachmentListWidget *>(

            mDocumentLoader->findObject(NMUI_MESSAGE_VIEWER_ATTALIST));

    if (mMessage && mAttaWidget) {

        // connect atta widget to listen progress value events

        QObject::connect(this, SIGNAL(progressValueChanged(int, int)),

                mAttaWidget, SLOT(setProgressBarValue(int, int)));

        mAttaWidget->setTextColor(Qt::black);

        // Set attawidget minimum & maximum size

        mAttaWidget->setMinimumWidth(mScreenSize.width());

        mAttaWidget->setMaximumWidth(mScreenSize.width());

        bool inserted(false);

        QList<NmMessagePart*> messageParts;

        mMessage->attachmentList(messageParts);

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

            NmMessagePart *part = messageParts[i];

            if (part &&

                ((part->contentDisposition().trimmed().startsWith("inline", Qt::CaseInsensitive)==false) ||

                 (part->contentType().trimmed().startsWith("image", Qt::CaseInsensitive)==false))) {

                QString fileName = part->attachmentName();

                // index starts from zero, next index is same as count

                int attaIndex = mAttaWidget->count();

                mAttaWidget->insertAttachment(attaIndex, fileName,

                                              NmUtilities::attachmentSizeString(part->size()));

                mAttaIdList.insert(attaIndex, part->partId());

                // check is part under fetch, add progress value to attachment widget

                if (mAttaManager.isFetching() && 

                        mAttaManager.partIdUnderFetch() == part->partId()) {

                    mAttaIndexUnderFetch = attaIndex;

                }

                inserted = true;

            }

        }

        if (inserted) {

            QObject::connect(mAttaWidget, SIGNAL(itemActivated(int)),

                    this, SLOT(openAttachment(int)));

        }

        else {

            // No attachments, set height to 0

            mAttaWidget->setMinimumHeight(0);

            mAttaWidget->setMaximumHeight(0);

        }

        // set this as a observer for attachment manager

        mAttaManager.setObserver(this);

    }

}

/*!

*/

void NmViewerView::openAttachment(int index)

{

    NM_FUNCTION;

    if (index >= 0) {

        NmId attaId = mAttaIdList.at(index);

        // reload message to get updates part sizes

        loadMessage();

        QList<NmMessagePart*> messageParts;

        if (mMessage) {

            mMessage->attachmentList(messageParts);

             NmId mailboxId = mMessage->envelope().mailboxId();

             NmId folderId = mMessage->envelope().folderId();

             NmId messageId = mMessage->envelope().messageId();

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

                 // message part found have to found

                 // and its fetched size is smaller than size, then start part fetch

                 if (messageParts[i]->partId() == attaId &&

                     messageParts[i]->size() > messageParts[i]->fetchedSize()) {

                     // do not start if there's already ongoing fetch

                     if (mAttaIndexUnderFetch == NmNotFoundError) {

                         mAttaIndexUnderFetch = index;

                         mAttaManager.fetchAttachment(mailboxId, folderId,

                                                      messageId, attaId);

                     }

                 }

                 // attachment is fetched, open file

                 else if (messageParts[i]->partId() == attaId) {

                     mAttaManager.cancelFetch();

                     XQSharableFile file = mUiEngine.messagePartFile(mailboxId, folderId,

                                                                     messageId, attaId);

                     int error = NmUtilities::openFile(file);