#include "WebView.h"

#include "qstmgestureevent.h"

#include "qstmfilelogger.h"

#include "bedrockprovisioning.h"

#include "ScrollHelper.h"

#include <QStyleOptionGraphicsItem>

#include <QWebPage>

#include <QWebHistory>

#include <QInputContext>

#include "Gestures/GestureRecognizer.h"

#ifdef ORBIT_UI

#include <hbinputmethod.h>

#endif // ORBIT_UI

namespace GVA {

const int ZoomAnimationDuration = 600;   //ms. Zooming transition duration

const int MaxZoomAnimationDuration = 2000;   //ms. Zooming transition duration

#ifdef Q_WS_MAEMO_5

const int TileUpdateEnableDelay = 10;         //Wait duration before tiling updates are enabled.

#else

const int TileUpdateEnableDelay = 150;         //Wait duration before tiling updates are enabled.

#endif

static const int MinDoubleClickZoomTargetWidth = 100;     //Target block width for applying double tap zoom

static const int ZoomCommitDuration = 60;                //Timeout before commiting zoom

static const qreal ZoomableContentMinWidth = 300.;

static const qreal InvalidCoord = 1e10;

static const int TouchDownTimeout = 200;

static const int HoverTimeout = 100;

#undef USE_KINETIC_SCROLLER

using namespace qstmGesture;

ScrollableWebContentView::ScrollableWebContentView(WebView* scrolledWidget, QGraphicsItem* parent)

    , m_isInputOn(false)

    , m_ignoreNextRelease(false)

    scrolledWidget->installEventFilter(this);

    setWidget(scrolledWidget);

    m_tileUpdateEnableTimer.setSingleShot(true);

    connect(&m_tileUpdateEnableTimer, SIGNAL(timeout()), this, SLOT(enableContentUpdates()));

    m_zoomCommitTimer.setSingleShot(true);

    connect(&m_zoomCommitTimer, SIGNAL(timeout()),this,SLOT(commitZoom()));

    //Setup zooming animator

    m_zoomAnimator = new QPropertyAnimation(this, "viewableRect");

    //m_zoomAnimator->setDuration(ZoomAnimationDuration);

    connect(m_zoomAnimator, SIGNAL(stateChanged(QAbstractAnimation::State,QAbstractAnimation::State)), 

            this, SLOT(zoomAnimationStateChanged(QAbstractAnimation::State,QAbstractAnimation::State)));

    m_isSuperPage = false;

    m_gesturesEnabled = true;

    m_isLoading = false;

    m_touchDownTimer = UiTimer::New();

    m_touchDownTimer->setTimerCallback((char*)"touchDownCallback");

    m_hoverTimer = UiTimer::New();

    m_hoverTimer->setTimerCallback((char*)"hoverCallback");

    m_touchDownTimer->setPriority(150);

    m_pinchFinishTime = QTime::currentTime();

    // ScrollHelper

    m_scrollHelper = new ScrollHelper(this);

    initScrollHelper();

    grabGesture(QStm_Gesture::assignedType());

    connect(this, SIGNAL(viewScrolled(QPoint&, QPoint&)), scrolledWidget, SLOT(viewScrolled(QPoint&, QPoint&)));

    installEventFilter(this);

}

void ScrollableWebContentView::initScrollHelper()

{

    qreal decel = BedrockSettings->value("KineticDeceleration").toDouble();

    m_scrollHelper->setDeceleration(decel);

    qreal maxFlickKoef = BedrockSettings->value("MaxFlickInViewportUnits").toDouble();

    qreal minFlickKoef = BedrockSettings->value("MinFlickInViewportUnits").toDouble();

    qreal midFlickKoef = BedrockSettings->value("MidFlickInViewportUnits").toDouble();

    m_scrollHelper->setFlickLimits(minFlickKoef, midFlickKoef, maxFlickKoef);

    qreal maxFlickSpeed = BedrockSettings->value("MaxFlickSpeed").toDouble();

    qreal minFlickSpeed = BedrockSettings->value("MinFlickSpeed").toDouble();

    qreal midFlickSpeed = BedrockSettings->value("MidFlickSpeed").toDouble();

    m_scrollHelper->setFlickSpeedLimits(minFlickSpeed, midFlickSpeed, maxFlickSpeed);

    int maxFlickDuration = BedrockSettings->value("MaxFlickDuration").toInt();

    int minFlickDuration = BedrockSettings->value("MinFlickDuration").toInt();

    int midFlickDuration = BedrockSettings->value("MidFlickDuration").toInt();

    m_scrollHelper->setFlickDurationLimits(minFlickDuration, midFlickDuration, maxFlickDuration);

    connect(m_scrollHelper, SIGNAL(scrollFinished()), this, SLOT(stopScrolling()));

    m_touchDownTimer->stop();

    delete m_touchDownTimer;

    m_hoverTimer->stop();

    delete m_hoverTimer;

void ScrollableWebContentView::stepZoom(bool zoomIn)

    if (isZooming()) {

        stopZoomAnimation();

        return;

    }

    qreal curScale =  scrollWidget()->scale();

    qreal destScale = curScale * scale;

    if (zoomIn && (destScale > m_viewportMetaData->m_maximumScale))

        destScale = m_viewportMetaData->m_maximumScale;

    else if (!zoomIn && (destScale < m_viewportMetaData->m_minimumScale))

        destScale = m_viewportMetaData->m_minimumScale;

    if(destScale == curScale)

    //QPointF zoomHotSpot(size().width()/2, size().height()/2); //center zoom looks ugly in some cases

    QPointF zoomHotSpot(0, 0);

    startZoomAnimationToHotSpot(zoomHotSpot, destScale);

}

int ScrollableWebContentView::zoomAnimationTime(bool zoomIn, qreal targetScale)

{

    qreal curScale = zoomScale(); 

    qreal scaleRatio = zoomIn ? (targetScale / curScale) :

                            1.2 * (curScale / targetScale);

    qreal fullScaleRatio = (m_viewportMetaData->m_maximumScale / m_viewportMetaData->m_minimumScale);

    return MaxZoomAnimationDuration * scaleRatio / fullScaleRatio;

}

void ScrollableWebContentView::toggleZoom(bool zoomIn)

{

    m_scrollHelper->stopScrollNoSignal();

    if (isZooming()) {

        stopZoomAnimation();

        commitZoom();

        return;

    }

    qreal scale = zoomIn ? m_viewportMetaData->m_maximumScale : m_viewportMetaData->m_minimumScale;

    int t = zoomAnimationTime(zoomIn, scale);

    QPointF zoomHotSpot(0, 0);

    startZoomAnimationToHotSpot(zoomHotSpot, scale, t);

}

QRectF ScrollableWebContentView::viewportRectInPageCoord(const QPointF& viewportHotSpot, 

                                                         const qreal destScale)

{

    QSizeF vpSize = size();

    QSizeF contentSize = webView()->size();

    QSizeF scaleVpSize(vpSize.width() / destScale, vpSize.height() / destScale);

    QPointF contentHotSpot = webView()->mapFromParent(viewportHotSpot);

    QPointF scaledHotSpot = viewportHotSpot / destScale; 

    QRectF destViewRect( contentHotSpot - scaledHotSpot, scaleVpSize);

    return destViewRect;

void ScrollableWebContentView::startZoomAnimationToHotSpot(const QPointF& viewportHotSpot, 

                                                           const qreal destScale, int animTime)

    QRectF destViewRect = viewportRectInPageCoord(viewportHotSpot, destScale);

    startZoomAnimation(destViewRect, animTime);

}

void ScrollableWebContentView::zoomToHotSpot(const QPointF& viewportHotSpot, const qreal destScale)

{

    QRectF destViewRect = viewportRectInPageCoord(viewportHotSpot, destScale);

    destViewRect = validateViewportRect(destViewRect);

    setViewableRect(destViewRect);

WebPageData ScrollableWebContentView::pageDataFromViewportInfo()

    if(!m_viewportMetaData->m_isValid) return WebPageData();

    // No viewport data saving or restoring for superpages

    if(isSuperPage()) return WebPageData();

    // invalidate viewport meta data after saving to history

    // cannot do it earlier because loadStarted event comes earlier than save to history

    if(m_isLoading)

        m_viewportMetaData->m_isValid = false;

    bool fitToScreen = qFuzzyCompare(m_viewportMetaData->m_width / webView()->size().width(), zoomScale());

    return WebPageData(m_viewportMetaData->m_maximumScale, m_viewportMetaData->m_minimumScale,

                       m_viewportMetaData->m_userScalable, m_viewportMetaData->m_initialScale,

                       geometry(), webView()->geometry(), scrollWidget()->scale(), size(),

                       m_viewportMetaData->m_specifiedData.m_width, m_viewportMetaData->m_specifiedData.m_height,

                       fitToScreen);

}

QSizeF ScrollableWebContentView::parentSize() const

{

    return static_cast<QGraphicsWidget*>(parentItem())->size();

}

void ScrollableWebContentView::setPageDataToViewportInfo(const WebPageData& data)

{

    if(!data.isValid()) return;

    // No viewport data saving or restoring for superpages

    if(isSuperPage()) return;

    m_viewportMetaData->m_specifiedData.m_width = data.specifiedWidth;

    m_viewportMetaData->m_specifiedData.m_height = data.specifiedHeight;

    m_viewportMetaData->m_width = data.viewportSize.width();

    m_viewportMetaData->m_height = data.viewportSize.height();

    if(m_viewportMetaData->m_width < 0 ||

       m_viewportMetaData->m_width < 0) {

        m_viewportMetaData->m_isValid = false;

        reset();

        return;

    }

    QSizeF newSize = parentSize();

    if(newSize.isEmpty())

        newSize = data.viewportSize;

    disableContentUpdates();

    //    updateViewportMetaDataFromPageTag();

    QSizeF vpSz(m_viewportMetaData->m_width, m_viewportMetaData->m_height);

    if(vpSz.isEmpty())

        vpSz = newSize;

    // sometimes on load from history webpage doesn't resize webView

    // set correct size of webView here

    webView()->setGeometry(QRectF( QPointF(0, 0),

                                   QSizeF(webView()->page()->mainFrame()->contentsSize())));

    qreal sc = data.scale; //qBound(m_viewportMetaData->m_minimumScale,data.scale,m_viewportMetaData->m_maximumScale);

    webView()->setScale(sc);

//    qreal fitToScreenScale = data.viewportSize.width() / webView()->size().width();

//    bool isFitToScreen = qFuzzyCompare(zoomScale(), fitToScreenScale);

    adjustViewportSize(data.viewportSize, newSize);

    m_viewportMetaData->adjustZoomValues(webView()->size());

    if(data.fitToScreen && newSize.width() != vpSz.width()) {

        qreal fitToScreenScale = size().width() / webView()->size().width();

        fitToScreenScale = qBound(m_viewportMetaData->m_minimumScale,

                                  fitToScreenScale,m_viewportMetaData->m_minimumScale);

        webView()->setScale(fitToScreenScale);

    }

//    else

//       updatePreferredContentSize();

    if (newSize.width() != m_viewportMetaData->m_width ||

        newSize.height() != m_viewportMetaData->m_height) {

        //setGeometry(0, 0, m_viewportMetaData->m_width, m_viewportMetaData->m_height);

        m_scrollHelper->setViewportSize(size());

    }

    if (data.webViewRect.isValid()) {

        QPointF webViewPos = data.webViewRect.topLeft();

        qreal newSc = webView()->scale(); // might be adjust by fitToScreen

        webViewPos = webViewPos / sc * newSc; // recalc pos if scale changed by fitToScreen

        QSizeF ss = webView()->size() * newSc;

        if(!ss.isEmpty()) {

            webViewPos.setX(qBound((qreal)m_viewportMetaData->m_width - (qreal)ss.width(), (qreal)webViewPos.x(), (qreal)0.0));

            webViewPos.setY(qBound((qreal)m_viewportMetaData->m_height - (qreal)ss.height(), (qreal)webViewPos.y(), (qreal)0.0));

            if(ss.width() < m_viewportMetaData->m_width) webViewPos.setX(0);

            if(ss.height() < m_viewportMetaData->m_height) webViewPos.setY(0);

        }

        setScrollWidgetPos(webViewPos);

    }

    enableContentUpdates();

//    updatePreferredContentSize();

    // emit scrolled event to hide/show url bar

    QPoint p(0, 0);

    if(!m_isLoading) {

        p = scrollPosition();

    }

    QPoint d(0, 0);

    emit viewScrolled(p, d);

WebPageData ScrollableWebContentView::defaultZoomData()

    WebPageData data;

    data.magic = 0;

    data.rect = rect();

    data.webViewRect = webView()->rect();

    data.viewportSize = QSizeF(m_viewportMetaData->m_width, m_viewportMetaData->m_height);

#ifdef VIEWPORT_ALWAYS_ALLOW_ZOOMING

    // Don't call updatePreferredContentSize() if we've over-ridden user-scalable because it

    // resets the content size and zoom factor.

    if(m_viewportMetaData->m_userScalableOverRidden)

        return;

#endif

    QSize s = m_viewportMetaData->getSpecifiedSize();

/*    if (!isSuperPage()) {

        prefferedHeight = qMax(m_viewportMetaData->m_width, m_viewportMetaData->m_height);

        prefferedWidth = m_viewportMetaData->m_width;        

        if(m_viewportMetaData->m_width * 1.5 < prefferedHeight) {

            // If the screen sides ratio is less than 3:2, than vertical width is

            // too narrow for normal page layout, but setting preffered width to the biggest side

            // makes page too scaled. Because of this set the page to the average of 2 viewport sides.

            prefferedWidth = (m_viewportMetaData->m_width + prefferedHeight) / 2;

        }

    }

//    if(m_viewportMetaData->m_specifiedData.)

*/

    webView()->page()->setPreferredContentsSize(s);

}

void ScrollableWebContentView::setPage(QWebPage* page)

{

    m_isSuperPage = false;

    m_gesturesEnabled = true;

    webView()->setPage(page);

    m_isSuperPage = true;

    disableContentUpdates();

    webView()->setScale(1.);

    //QSize contentSize = (webView()->size() * zoomScale()).toSize();

    //QRect webViewRect(0, 0, size().width(), contentSize.height());

    //webView()->setGeometry(webViewRect);

    setScrollWidgetPos(QPointF(0, 0));

    enableContentUpdates();

#ifdef VIEWPORT_ALWAYS_ALLOW_ZOOMING

    updatePreferredContentSize();

    //viewportWidget()->updatePreferredContentSize(QSize(m_viewportMetaData->m_width

     //                                                  , m_viewportMetaData->m_height));

#else

    updatePreferredContentSize();

#endif

}

void ScrollableWebContentView::updateViewportMetaDataFromPageTag()

{

    QWebPage* page = webView()->page();

    if (!page)

        return;

    QWebFrame* frame = page->mainFrame();

    QMap<QString, QString> metaData = frame->metaData();

    QString viewportTag = metaData.value("viewport");

    QRect clientRect = geometry().toAlignedRect();

    ViewportMetaDataParser parser(clientRect);

    parser.parse(viewportTag, *m_viewportMetaData);

    m_viewportMetaData->adjustZoomValues(webView()->size());

    QWebPage* page = webView()->page();

//    if(m_viewportMetaData->m_isValid) return;

    disableContentUpdates();

    webView()->setScale(1);

    // sometimes on load from history webpage doesn't resize webView

    // set correct size of webView here

    webView()->setGeometry(QRectF( QPointF(0, 0),

                                   QSizeF(webView()->page()->mainFrame()->contentsSize())));

    updateViewportMetaDataFromPageTag();

    //setViewportWidgetGeometry(QRectF(QPointF(),