/*

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

* All rights reserved.

*

*

*

*

*/

#include "GWebContentView.h"

#include "GWebContentViewWidget.h"

#include "GWebContentViewJSObject.h"

#include "ChromeWidget.h"

#include "WebViewEventContext.h"

#include "browserpagefactory.h"

#include "wrtbrowsercontainer.h"

#include "webpagecontroller.h"

#ifndef NO_QSTM_GESTURE

#include "qstmgestureevent.h"

#endif

#include <QGraphicsWebView>

#include <QWebHistory>

#include <QWebPage>

#include <QWebFrame>

#include <QTimeLine>

#include <QDebug>

#define safe_connect(src, srcSig, target, targetSlot) \

  { int res = connect(src, srcSig, target, targetSlot); assert(res); }

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_currentSuperPage(m_superPages.begin()),

      m_currentPageIsSuperPage(false),

  {

      setObjectName(objectName);

      qDebug() << "GWebContentView::GWebContentView: this=" << this;

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

#ifndef __gva_no_chrome__

#endif

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

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

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

#ifdef NO_QSTM_GESTURE

      m_touchNavigation->setChromeWidget(m_chrome);

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

#endif

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

          wrtPage->setWebWidget(webWidget());

          pageCreated(wrtPage);

      }

      connectAll();

  }

  GWebContentView::~GWebContentView() {

      disconnect(m_jsObject);

      disconnect(webWidget());

      delete m_touchNavigation;

      delete m_widget;

      foreach(GWebPage *page, m_superPages) {

          delete page;

      }

  }

void GWebContentView::bitmapZoomStop()

{

    if (m_timer) {

        m_timer->stop();

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

        delete m_timer;

    }

    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())

    }else {

        if (m_timer->isSingleShot()) {

            m_timer->setSingleShot(false);

            m_timer->start(1);

        }

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

        m_value *= KZoomOutStep;

    }

}

{

    Q_UNUSED(deltaPercent)

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

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

            if (!m_timer->isSingleShot())

                m_value /= KZoomInStep;

            bitmapZoomStop();

        }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());

        }

}

{

    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());

        }

    }

}

  void GWebContentView::connectAll() {

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

#ifndef __gva_no_chrome__

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

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

    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)));

#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)));

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

#endif

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

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

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

  }

  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);

  }

  GWebContentViewWidget *GWebContentView::webWidget() const {

    return m_widget;

  }

  QString GWebContentView::title() const {

    return webWidget()->title();

  }

  QUrl GWebContentView::url() {

    return webWidget()->url();

  }

  QWebPage* GWebContentView::wrtPage() {

    return m_widget->wrtPage();

  }

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

       */

  }

  void GWebContentView::triggerAction(const QString & action)

  {

    qDebug() << "GWebContentView::triggerAction: " << action;

    QWebPage::WebAction webAction;

      webAction = QWebPage::Stop;

    else if (action=="Back")

      webAction = QWebPage::Back;

      webAction = QWebPage::Reload;

    else if (action=="Forward")

      webAction = QWebPage::Forward;

    else

      return;

    webWidget()->triggerPageAction(webAction);

  }

  void GWebContentView::deactivateZoomActions()

  {

  }

  void GWebContentView::changeZoomAction(qreal zoom){

        deactivateZoomActions();

    }

    else {

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

      }

      else {

      }

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

      }

      else {

      }

    }

  }

  void GWebContentView::setZoomFactor(qreal factor){

        webWidget()->setZoomFactor(factor);

  }

  qreal GWebContentView::getZoomFactor() const {

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

  }

  void GWebContentView::activate() {

      qDebug() << "GWebContentView::activate";

      ControllableViewBase::activate();

  }

  void GWebContentView::deactivate() {

      qDebug() << "GWebContentView::deactivate";

      ControllableViewBase::deactivate();

  }

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

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

//          action->setObjectName(name);

//          list.append(action);

//      }

//  }

  /*!

    Return the list of public QActions most relevant to the view's current context.

    @return  List of public actions

  */

  QList<QAction *> GWebContentView::getContext()

  {

      // Get some of the actions from the page (there are many more available) and build a list

      // list of them.

      QList<QAction*> actions;

      /* Add zoomIn and zoomOut actions created earlier*/

      return actions;

  }

  QAction * GWebContentView::getAction(const QString & action)

  {

  }

  void GWebContentView::scrollViewBy(int dx, int dy)

  {

      wrtPage()->mainFrame()->scroll(dx, dy);

  }

  void GWebContentView::scrollViewTo(int x, int y)

  {

      wrtPage()->mainFrame()->setScrollPosition(QPoint(x, y));

  }

  void GWebContentView::showMessageBox(WRT::MessageBoxProxy* proxy)

  {

  /*

      QMessageBox msgBox(this);

      msgBox.setText(proxy->m_text);

      msgBox.setInformativeText(proxy->m_informativeText);

      msgBox.setDetailedText(proxy->m_detailedText);

      msgBox.setStandardButtons(proxy->m_buttons);

      msgBox.setDefaultButton(proxy->m_defaultButton);

      msgBox.setIcon(proxy->m_icon);

      int ret = msgBox.exec();

      */

      QString displayText = proxy->m_text + QLatin1String("\n") + QLatin1String("\n")+ proxy->m_detailedText + QLatin1String("\n") + QLatin1String("\n") + proxy->m_informativeText;

      int ret = QMessageBox::warning(0/* TODO: find appropriate widget if required or just remove this widget()*/,

                                     proxy->m_text, displayText, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);

      proxy->onMessageBoxResponse(ret);

  }

  void GWebContentView::loadUrlToCurrentPage(const QString & url)

  {

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

        activePage->mainFrame()->load(url);

      }

  }

  QWebPage *GWebContentView::currentPage() {

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

      return activePage;

  }

  int GWebContentView::contentWidth()

  {

    return currentPage()->mainFrame()->contentsSize().width();

  }

  int GWebContentView::contentHeight()

  {

    return currentPage()->mainFrame()->contentsSize().height();

  }

  void GWebContentView::stop()

  {

    webWidget()->stop();

  }

  void GWebContentView::back()

  {

    qDebug() << "GWebContentView::back";

    webWidget()->back();

  }

  void GWebContentView::forward()

  {

    webWidget()->forward();

  }

  void GWebContentView::reload()

  {

    webWidget()->reload();

  }

  int GWebContentView::scrollX()

  {

    return currentPage()->mainFrame()->scrollPosition().x();

  }

  int GWebContentView::scrollY()

  {

    return currentPage()->mainFrame()->scrollPosition().y();

  }

  void GWebContentView::zoom(bool in)

  {

    m_zoomIn = in;

      m_timeLine = new QTimeLine();

      connect(m_timeLine, SIGNAL(valueChanged(qreal)),

        this, SLOT(updateZoom(qreal)));

    }

    else {

      m_timeLine->stop();