/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not,

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

#include "GWebContentView.h"

#include "GWebContentViewWidget.h"

#include "GWebContentViewJSObject.h"

#include "SuperPageView.h"

#include "ChromeWidget.h"

#include "WebViewEventContext.h"

#include "browserpagefactory.h"

#include "wrtbrowsercontainer.h"

#ifdef BEDROCK_TILED_BACKING_STORE

#include "WebContentViewWidget.h"

#endif

#include "webpagecontroller.h"

#include "Utilities.h"

#include "GSuperWebPage.h"

#ifndef NO_QSTM_GESTURE

#include "qstmgestureevent.h"

#endif

#include <QGraphicsWebView>

#include <QWebHistory>

#include <QWebPage>

#include <QWebFrame>

#include <QTimeLine>

#include <QDebug>

#include <QtGui>

namespace GVA {

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

  const qreal KZoomInStep = 1.05;

  const qreal KZoomOutStep = 0.95238;

  GWebContentView::GWebContentView(ChromeWidget *chrome, QObject * parent, const QString &objectName)

    : ControllableViewBase(parent),

      m_networkMgr(0),

      m_chrome(chrome),

      m_timeLine(0),

      m_zoomIn(false),

      m_backEnabled(false),

      m_forwardEnabled(false),

      m_sharedPage(0),

      m_currentSuperPage(m_superPages.begin()),

      m_currentPageIsSuperPage(false),

      m_timer(NULL),

      m_enabled(true)

  {

      setObjectName(objectName);

      WRT::WrtBrowserContainer* page = BrowserPageFactory::openBrowserPage();

      setActions();

#ifdef BEDROCK_TILED_BACKING_STORE

      m_widget = new WebContentViewWidget(parent, page);

      connect(m_widget

              , SIGNAL(updateZoomActions(bool,bool))

              , this

              , SLOT(setZoomActions(bool, bool)));

#else

      m_widget = new GWebContentViewWidget(parent, this, page);

#endif

#ifndef __gva_no_chrome__

      setJSObject(objectName);

#endif

      m_networkMgr = webWidget()->page()->networkAccessManager();

      webWidget()->page()->currentFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);

      webWidget()->page()->currentFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);

#ifndef BEDROCK_TILED_BACKING_STORE

#ifdef NO_QSTM_GESTURE

      m_touchNavigation = new GContentViewTouchNavigation(page, m_widget);

      m_touchNavigation->setChromeWidget(m_chrome);

      m_touchNavigation->setParent(m_jsObject);

      m_touchNavigation->setObjectName("touchNav");

      safe_connect(m_touchNavigation, SIGNAL(mouseEvent(QEvent::Type)) , this, SIGNAL(contentViewMouseEvent(QEvent::Type)));

      safe_connect(m_touchNavigation, SIGNAL(longPressEvent(QPoint)),

                   webWidget(), SLOT(onLongPressEvent(QPoint)));

#endif

#endif

      WRT::WrtBrowserContainer * wrtPage = static_cast<WRT::WrtBrowserContainer *>(page);

      if (wrtPage) {

          wrtPage->setWebWidget(webWidget());

          pageCreated(wrtPage);

      }

      connectAll();

  }

  GWebContentView::~GWebContentView() {

      disconnect(m_jsObject);

      disconnect(webWidget());

#ifndef BEDROCK_TILED_BACKING_STORE

      delete m_touchNavigation;

#endif

      foreach(QAction * action, m_actions) {

          delete action;

      }

      delete m_widget;

      foreach(GSuperWebPage *page, m_superPages) {

          delete page;

      }

  }

#ifdef BEDROCK_TILED_BACKING_STORE

void GWebContentView::zoomIn(qreal deltaPercent)

{

    //FIX ME : Do we need deltaPercent?

    Q_UNUSED(deltaPercent);

    m_widget->setPageZoom(true);

}

void GWebContentView::zoomOut(qreal deltaPercent)

{

    //FIX ME : Do we need deltaPercent?

    Q_UNUSED(deltaPercent);

    m_widget->setPageZoom(false);

}

#endif

#ifndef BEDROCK_TILED_BACKING_STORE

void GWebContentView::bitmapZoomStop()

{

    if (m_timer) {

        m_timer->stop();

        disconnect(m_timer,SIGNAL(timeout()));

        delete m_timer;

        m_timer = NULL;

    }

    qreal zoomFactor = m_value * webWidget()->zoomFactor();

    ((zoomFactor+0.001) >= webWidget()->maximumScale() )? webWidget()->setZoomFactor(webWidget()->maximumScale()):webWidget()->setZoomFactor(zoomFactor);

    webWidget()->bitmapZoomCleanup();

}

void GWebContentView::zoomP()

{

    if ((m_value * webWidget()->zoomFactor()) >  webWidget()->maximumScale()) {

        if (m_timer && m_timer->isActive())

            bitmapZoomStop();

    }else {

        if (m_timer->isSingleShot()) {

            m_timer->setSingleShot(false);

            m_timer->start(1);

        }

        webWidget()->setBitmapZoom(m_value * webWidget()->zoomFactor());

        m_value *= KZoomInStep;

    }

}

void GWebContentView::zoomN()

{

    if ((m_value * webWidget()->zoomFactor()) <  webWidget()->minimumScale()){

        if (m_timer && m_timer->isActive())

            bitmapZoomStop();

    }else {

        if (m_timer->isSingleShot()) {

            m_timer->setSingleShot(false);

            m_timer->start(1);

        }

        webWidget()->setBitmapZoom(m_value * webWidget()->zoomFactor());

        m_value *= KZoomOutStep;

    }

}

void GWebContentView::zoomIn(qreal deltaPercent)

{

    Q_UNUSED(deltaPercent)

    if (webWidget() && webWidget()->isUserScalable()) {

        if (m_timer && m_timer->isActive()) {

            if (!m_timer->isSingleShot())

                m_value /= KZoomInStep;

            bitmapZoomStop();

            return;

        }else if (!m_timer)

            m_timer = new QTimer(this);

        m_value = KZoomInStep;

        if ((m_value * webWidget()->zoomFactor()) <  webWidget()->maximumScale()) {

            webWidget()->createPageSnapShot();

            connect(m_timer,SIGNAL(timeout()),this,SLOT(zoomP()));

            zoomP();

            m_timer->setSingleShot(true);

            m_timer->start(500);

        }else {

            delete m_timer;

            m_timer = NULL;

            webWidget()->setZoomFactor(m_value * webWidget()->zoomFactor());

        }

    }

}

void GWebContentView::zoomOut(qreal deltaPercent)

{

    Q_UNUSED(deltaPercent)

    if (webWidget() && webWidget()->isUserScalable()) {

        if (m_timer && m_timer->isActive()) {

            if (!m_timer->isSingleShot())

                m_value /= KZoomOutStep;

            bitmapZoomStop();

            return;

        }else if (!m_timer)

            m_timer = new QTimer(this);

        m_value = KZoomOutStep;

        if ((m_value * webWidget()->zoomFactor()) >  webWidget()->minimumScale()) {

            webWidget()->createPageSnapShot();

            connect(m_timer,SIGNAL(timeout()),this,SLOT(zoomN()));

            zoomN();

            m_timer->setSingleShot(true);

            m_timer->start(500);

        }else {

            delete m_timer;

            m_timer = NULL;

            webWidget()->setZoomFactor(m_value * webWidget()->zoomFactor());

        }

    }

}

#endif

  void GWebContentView::connectAll() {

    //qDebug() << "GWebContentView::connectAll: " << widget();

#ifndef __gva_no_chrome__

#ifndef BEDROCK_TILED_BACKING_STORE

    safe_connect(widget(), SIGNAL(contextEvent(::WebViewEventContext *)),

                 m_jsObject, SLOT(onContextEvent(::WebViewEventContext *)));

#else

    safe_connect(this

                 , SIGNAL(contextEvent(::WebViewEventContext*))

                 ,  m_jsObject

                 , SLOT(onContextEvent(::WebViewEventContext*)));

    safe_connect(m_widget

                , SIGNAL(contextEventObject(QWebHitTestResult*))

                , this

                , SLOT(handleContextEventObject(QWebHitTestResult*)));

    safe_connect(m_widget

                 , SIGNAL(viewScrolled(QPoint&, QPoint&))

                 , this

                 , SLOT(handleViewScrolled(QPoint&, QPoint&)));

#endif

    QObject::connect(webWidget(), SIGNAL(titleChanged(const QString &)), m_jsObject, SIGNAL(titleChanged(const QString &)));

    QObject::connect(webWidget(), SIGNAL(loadStarted()), m_jsObject, SIGNAL(loadStarted()));

    QObject::connect(webWidget(), SIGNAL(loadProgress(int)), m_jsObject, SIGNAL(loadProgress(int)));

    QObject::connect(webWidget(), SIGNAL(loadProgress(int)), this, SIGNAL(loadProgress(int)));

#endif

    QObject::connect(webWidget(), SIGNAL(loadStarted()), this, SLOT(onLoadStarted()));

    QObject::connect(webWidget(), SIGNAL(loadFinished(bool)), this, SLOT(onLoadFinished(bool)));

    QObject::connect(webWidget(), SIGNAL(urlChanged(const QUrl&)), this, SLOT(onUrlChanged(const QUrl&)));

#ifndef __gva_no_chrome__

    QObject::connect(this, SIGNAL(urlChanged(const QString&)), m_jsObject, SIGNAL(urlChanged(const QString&)));

    QObject::connect(this, SIGNAL(backEnabled(bool)), m_jsObject, SIGNAL(backEnabled(bool)));

    QObject::connect(this, SIGNAL(forwardEnabled(bool)), m_jsObject, SIGNAL(forwardEnabled(bool)));

    QObject::connect(this, SIGNAL(loadFinished(bool)), m_jsObject, SIGNAL(loadFinished(bool)));

    QObject::connect(this, SIGNAL(secureConnection(bool)), m_jsObject, SIGNAL(secureConnection(bool)));

#ifndef BEDROCK_TILED_BACKING_STORE

    connect(m_touchNavigation, SIGNAL(startingPanGesture(int)), m_jsObject, SIGNAL(startingPanGesture(int)));

#endif

#endif

    connect(WebPageController::getSingleton(), SIGNAL(pageCreated(WRT::WrtBrowserContainer*)),

            this, SLOT(pageCreated(WRT::WrtBrowserContainer*)));

    connect(WebPageController::getSingleton(), SIGNAL(pageChanged(WRT::WrtBrowserContainer*, WRT::WrtBrowserContainer*)),

            this, SLOT(pageChanged(WRT::WrtBrowserContainer*, WRT::WrtBrowserContainer*)));

    connect(WebPageController::getSingleton(), SIGNAL(showMessageBox(WRT::MessageBoxProxy*)),

            this, SLOT(showMessageBox(WRT::MessageBoxProxy*)));

  }

  QVariant GWebContentView::getContentWindowObject() {

    try {

        return webWidget()->page()->mainFrame()->evaluateJavaScript("window");

    }

    catch(...) {

        qDebug() << "GWebContentView::getContentWindowObject: caught expection";

        return QVariant();

    }

  }

  QGraphicsWidget* GWebContentView::widget() const {

    return static_cast<QGraphicsWidget*>(m_widget);

  }

#ifdef BEDROCK_TILED_BACKING_STORE

  QGraphicsWebView* GWebContentView::webWidget() const {

    return m_widget->webView();

  }

#else

  GWebContentViewWidget *GWebContentView::webWidget() const {

    return m_widget;

  }

#endif

  QString GWebContentView::title() const {

    return webWidget()->title();

  }

  QUrl GWebContentView::url() {

    return webWidget()->url();

  }

  QWebPage* GWebContentView::wrtPage() {

#ifdef BEDROCK_TILED_BACKING_STORE

    return m_widget->page();

#else

    return m_widget->wrtPage();

#endif

  }

  void GWebContentView::setActions(){

      QAction* action;

      action = m_actions["zoomIn"] =  new QAction("zoomIn", this);

      action->setObjectName("zoomIn");

      connect(action, SIGNAL(triggered()), this, SLOT(zoomIn()));

      action = m_actions["zoomOut"] = new QAction("zoomOut", this);

      action->setObjectName("zoomOut");

      /* Disable zoomOut action initially as we are the the minimum scale */

      /* Revisit this to determine whether we can use the change signal to

       * set the zoomOut button image initially as well

       */

      action->setEnabled(false);

      connect(action, SIGNAL(triggered()), this, SLOT(zoomOut()));

      action = m_actions["zoom"] = new QAction("zoom", this);

      action->setObjectName("zoom");

      action =  m_actions["winview"]=  new QAction("winview", this);

      action->setObjectName("winview");

      action = m_actions["menu"] =  new QAction("menu", this);

      action->setObjectName("menu");

      action = m_actions["mostvisited"] =  new QAction("mostvisited", this);

      action->setObjectName("mostvisited");

      action = m_actions["toggletb"] = new QAction("toggletb", this);

      action->setObjectName("toggletb");

  }

  void GWebContentView::triggerAction(const QString & action)

  {

    QWebPage::WebAction webAction;

    if (action=="Stop")

      webAction = QWebPage::Stop;

    else if (action=="Back")

      webAction = QWebPage::Back;

    else if (action=="Reload")

      webAction = QWebPage::Reload;

    else if (action=="Forward")

      webAction = QWebPage::Forward;

    else

      return;

    webWidget()->triggerPageAction(webAction);

  }

  void GWebContentView::deactivateZoomActions()

  {

    m_actions.value("zoomIn")->setEnabled(false);

    m_actions.value("zoomOut")->setEnabled(false);

  }

  void GWebContentView::changeZoomAction(qreal zoom){

  #ifndef BEDROCK_TILED_BACKING_STORE

    if (!webWidget()) return;

    if (!(webWidget()->isUserScalable() ) ){

        deactivateZoomActions();

    }

    else {

      QAction * zoomOutAction = m_actions.value("zoomOut");

      QAction * zoomInAction = m_actions.value("zoomIn");

      if (zoom <= webWidget()->minimumScale() ) {

         zoomOutAction->setEnabled(false);

      }

      else {

         zoomOutAction->setEnabled(true);

      }

      if (zoom >= webWidget()->maximumScale()  ){

         zoomInAction->setEnabled(false);

      }

      else {

         zoomInAction->setEnabled(true);

      }

    }

#endif

  }

  void GWebContentView::setZoomFactor(qreal factor){

    if (webWidget())

#ifdef BEDROCK_TILED_BACKING_STORE

        webWidget()->setScale(factor);

#else

        webWidget()->setZoomFactor(factor);

#endif

  }

#ifdef BEDROCK_TILED_BACKING_STORE

QGraphicsWidget* GWebContentView::webWidgetConst()  {

    return m_widget;

}

void GWebContentView::setZoomActions(bool enableZoomIn, bool enableZoomOut)

{

    m_actions.value("zoomIn")->setEnabled(enableZoomIn);

    m_actions.value("zoomOut")->setEnabled(enableZoomOut);

}

  qreal GWebContentView::getZoomFactor(){

    return webWidgetConst() ? webWidgetConst()->scale() : 0.0;

  }

#else

  qreal GWebContentView::getZoomFactor() const {

    return webWidgetConst() ? webWidgetConst()->zoomFactor() : 0.0;

  }

#endif

void GWebContentView::activate() {

#ifdef BEDROCK_TILED_BACKING_STORE

    WRT::WrtBrowserContainer* newPage = WebPageController::getSingleton()->currentPage();

    changeContentViewZoomInfo(newPage);

#endif

    ControllableViewBase::activate();

  }

  void GWebContentView::deactivate() {

#ifdef BEDROCK_TILED_BACKING_STORE

    if (!currentPageIsSuperPage()) {

        WRT::WrtBrowserContainer* currentPage = WebPageController::getSingleton()->currentPage();

        currentPage->setPageZoomMetaData(m_widget->currentPageInfo());

    }

#endif

      ControllableViewBase::deactivate();

  }

//  static void appendAction(QWebPage* page, QList<QAction*> &list, enum QWebPage::WebAction webAction, const QString &name) {

//      QAction *action = page->action(webAction);

//      if (action) {

//          action->setObjectName(name);

//          list.append(action);

//      }