/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information (qt-info@nokia.com)
**
** This file is part of the Graphics Dojo project on Qt Labs.
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 or 3.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://www.fsf.org/licensing/licenses/info/GPLv2.html and
** http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at qt-sales@nokia.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include "FlickCharm.h"

#include <QAbstractScrollArea>
#include <QApplication>
#include <QBasicTimer>
#include <QEvent>
#include <QHash>
#include <QList>
#include <QMouseEvent>
#include <QScrollBar>
#include <QWebFrame>
#include <QWebView>
#include <QGraphicsWebView>
#include <QGraphicsSceneMouseEvent>

#include <QDebug>

struct FlickData {
    typedef enum { Steady, Pressed, ManualScroll, AutoScroll, Stop } State;
    State state;
    QObject *widget;
    QPoint pressPos;
    QPoint offset;
    QPoint dragPos;
    QPoint speed;
    QList<QEvent*> ignored;
};

class FlickCharmPrivate
{
public:
    QHash<QObject*, FlickData*> flickData;
    QBasicTimer ticker;
};

FlickCharm::FlickCharm(QObject *parent): QObject(parent)
{
    d = new FlickCharmPrivate;
}

FlickCharm::~FlickCharm()
{
    delete d;
}

void FlickCharm::activateOn(QWidget *widget)
{
    QAbstractScrollArea *scrollArea = dynamic_cast<QAbstractScrollArea*>(widget);
    if (scrollArea) {
        scrollArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
        scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);

        QWidget *viewport = scrollArea->viewport();

        viewport->installEventFilter(this);
        scrollArea->installEventFilter(this);

        d->flickData.remove(viewport);
        d->flickData[viewport] = new FlickData;
        d->flickData[viewport]->widget = widget;
        d->flickData[viewport]->state = FlickData::Steady;

        return;
    }
}

void FlickCharm::activateOn(QWebView *webView)
{
    if (webView) {
        QWebFrame *frame = webView->page()->mainFrame();
        frame->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
        frame->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);

        webView->installEventFilter(this);

        d->flickData.remove(webView);
        d->flickData[webView] = new FlickData;
        d->flickData[webView]->widget = webView;
        d->flickData[webView]->state = FlickData::Steady;

        return;
    }
}

void FlickCharm::activateOn(QGraphicsWebView *webView)
{
    qDebug() << "FlickCharm::activateOn";
    if (webView) {
        QWebFrame *frame = webView->page()->mainFrame();
        frame->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff);
        frame->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff);

        webView->installEventFilter(this);

        d->flickData.remove(webView);
        d->flickData[webView] = new FlickData;
        d->flickData[webView]->widget = webView;
        d->flickData[webView]->state = FlickData::Steady;

        return;
    }
}

void FlickCharm::deactivateFrom(QWidget *widget)
{
    QAbstractScrollArea *scrollArea = dynamic_cast<QAbstractScrollArea*>(widget);
    if (scrollArea) {
        QWidget *viewport = scrollArea->viewport();

        viewport->removeEventFilter(this);
        scrollArea->removeEventFilter(this);

        delete d->flickData[viewport];
        d->flickData.remove(viewport);

        return;
    }

    QWebView *webView = dynamic_cast<QWebView*>(widget);
    if (webView) {
        webView->removeEventFilter(this);

        delete d->flickData[webView];
        d->flickData.remove(webView);

        return;
    }
}

static QPoint scrollOffset(QObject *widget)
{
    int x = 0, y = 0;

    QGraphicsWebView *gWebView = dynamic_cast<QGraphicsWebView*>(widget);
    if (gWebView) {
        QWebFrame *frame = gWebView->page()->mainFrame();
        x = frame->evaluateJavaScript("window.scrollX").toInt();
        y = frame->evaluateJavaScript("window.scrollY").toInt();
    }

    QAbstractScrollArea *scrollArea = dynamic_cast<QAbstractScrollArea*>(widget);
    if (scrollArea) {
        x = scrollArea->horizontalScrollBar()->value();
        y = scrollArea->verticalScrollBar()->value();
    }

    QWebView *webView = dynamic_cast<QWebView*>(widget);
    if (webView) {
        QWebFrame *frame = webView->page()->mainFrame();
        x = frame->evaluateJavaScript("window.scrollX").toInt();
        y = frame->evaluateJavaScript("window.scrollY").toInt();
    }

    return QPoint(x, y);
}

static void setScrollOffset(QObject *widget, const QPoint &p)
{
    QGraphicsWebView *gWebView = dynamic_cast<QGraphicsWebView*>(widget);
    if (gWebView) {
        QWebFrame *frame = gWebView->page()->mainFrame();
        if (frame)
            frame->evaluateJavaScript(QString("window.scrollTo(%1,%2);").arg(p.x()).arg(p.y()));
        return;
    }

    QAbstractScrollArea *scrollArea = dynamic_cast<QAbstractScrollArea*>(widget);
    if (scrollArea) {
        scrollArea->horizontalScrollBar()->setValue(p.x());
        scrollArea->verticalScrollBar()->setValue(p.y());
        return;
    }

    QWebView *webView = dynamic_cast<QWebView*>(widget);
    QWebFrame *frame = webView ? webView->page()->mainFrame() : 0;
    if (frame)
        frame->evaluateJavaScript(QString("window.scrollTo(%1,%2);").arg(p.x()).arg(p.y()));
}

static QPoint deaccelerate(const QPoint &speed, int a = 1, int max = 64)
{
    int x = qBound(-max, speed.x(), max);
    int y = qBound(-max, speed.y(), max);
    x = (x == 0) ? x : (x > 0) ? qMax(0, x - a) : qMin(0, x + a);
    y = (y == 0) ? y : (y > 0) ? qMax(0, y - a) : qMin(0, y + a);
    return QPoint(x, y);
}

bool FlickCharm::eventFilter(QObject *object, QEvent *event)
{
//    qDebug() << "FlickCharm::eventFilter: " << object << event;
//    if (!object->isWidgetType())
//        return false;

    QEvent::Type type = event->type();
    switch (type) {
        case QEvent::MouseButtonPress:
        case QEvent::MouseButtonRelease:
        case QEvent::MouseMove:
        case QEvent::GraphicsSceneMousePress:
        case QEvent::GraphicsSceneMouseRelease:
        case QEvent::GraphicsSceneMouseMove:
            break;
        default:
            return false;
    }

    QPoint eventPos;
    QEvent::Type eventType;
    Qt::MouseButtons eventButtons;
    QMouseEvent *mouseEvent = dynamic_cast<QMouseEvent*>(event);
    if (mouseEvent) {
        if (mouseEvent->modifiers() != Qt::NoModifier)
            return false;
        eventPos = mouseEvent->pos();
        eventType = mouseEvent->type();
        eventButtons = mouseEvent->buttons();
    }
    else {
        QGraphicsSceneMouseEvent *mouseEvent = dynamic_cast<QGraphicsSceneMouseEvent*>(event);
        if (mouseEvent && mouseEvent->modifiers() == Qt::NoModifier) {
            eventPos = mouseEvent->pos().toPoint();
            eventType = mouseEvent->type();
            eventButtons = mouseEvent->buttons();
        }
        else
            return false;
    }

//    QWidget *viewport = dynamic_cast<QWidget*>(object);
    FlickData *data = d->flickData.value(object);
    if (!data || data->ignored.removeAll(event)) {
        return false;
    }

    bool consumed = false;
    switch (data->state) {

    case FlickData::Steady:
        if (eventType == QEvent::MouseButtonPress ||
            eventType == QEvent::GraphicsSceneMousePress)
            if (eventButtons == Qt::LeftButton) {
                consumed = true;
                data->state = FlickData::Pressed;
                data->pressPos = eventPos;
                data->offset = scrollOffset(data->widget);
            }
        break;

    case FlickData::Pressed:
        if (eventType == QEvent::MouseButtonRelease) {
            consumed = true;
            data->state = FlickData::Steady;

            QMouseEvent *event1 = new QMouseEvent(QEvent::MouseButtonPress,
                                                  data->pressPos, Qt::LeftButton,
                                                  Qt::LeftButton, Qt::NoModifier);
            QMouseEvent *event2 = new QMouseEvent(*mouseEvent);

            data->ignored << event1;
            data->ignored << event2;
            QApplication::postEvent(object, event1);
            QApplication::postEvent(object, event2);
        }
        else if (eventType == QEvent::GraphicsSceneMouseRelease) {
            consumed = true;
            data->state = FlickData::Steady;

            QGraphicsSceneMouseEvent *origMouseEvent = static_cast<QGraphicsSceneMouseEvent*>(event);
            QGraphicsSceneMouseEvent *event1 =
                    new QGraphicsSceneMouseEvent(QEvent::GraphicsSceneMousePress);
            event1->setPos(origMouseEvent->pos());
            event1->setScenePos(origMouseEvent->scenePos());
            event1->setLastPos(origMouseEvent->lastPos());
            event1->setLastScenePos(origMouseEvent->lastScenePos());
            event1->setButtons(origMouseEvent->buttons());
            event1->setButton(origMouseEvent->button());
            event1->setModifiers(origMouseEvent->modifiers());

            QGraphicsSceneMouseEvent *event2 = new QGraphicsSceneMouseEvent(origMouseEvent->type());
            event2->setPos(origMouseEvent->pos());
            event2->setScenePos(origMouseEvent->scenePos());
            event2->setLastPos(origMouseEvent->lastPos());
            event2->setLastScenePos(origMouseEvent->lastScenePos());
            event2->setButtons(origMouseEvent->buttons());
            event2->setButton(origMouseEvent->button());
            event2->setModifiers(origMouseEvent->modifiers());

            data->ignored << event1;
            data->ignored << event2;
            QApplication::postEvent(object, event1);
            QApplication::postEvent(object, event2);
        }
        if (eventType == QEvent::MouseMove ||
            eventType == QEvent::GraphicsSceneMouseMove) {
            consumed = true;
            data->state = FlickData::ManualScroll;
            data->dragPos = QCursor::pos();
            if (!d->ticker.isActive())
                d->ticker.start(20, this);
        }
        break;

    case FlickData::ManualScroll:
        if (eventType == QEvent::MouseMove ||
            eventType == QEvent::GraphicsSceneMouseMove) {
            consumed = true;
            QPoint delta = eventPos - data->pressPos;
            setScrollOffset(data->widget, data->offset - delta);
        }
        if (eventType == QEvent::MouseButtonRelease ||
            eventType == QEvent::GraphicsSceneMouseRelease) {
            consumed = true;
            data->state = FlickData::AutoScroll;
        }
        break;

    case FlickData::AutoScroll:
        if (eventType == QEvent::MouseButtonPress ||
            eventType == QEvent::GraphicsSceneMousePress) {
            consumed = true;
            data->state = FlickData::Stop;
            data->speed = QPoint(0, 0);
            data->pressPos = eventPos;
            data->offset = scrollOffset(data->widget);
        }
        if (eventType == QEvent::MouseButtonRelease ||
            eventType == QEvent::GraphicsSceneMouseRelease) {
            consumed = true;
            data->state = FlickData::Steady;
            data->speed = QPoint(0, 0);
        }
        break;

    case FlickData::Stop:
        if (eventType == QEvent::MouseButtonRelease ||
            eventType == QEvent::GraphicsSceneMouseRelease) {
            consumed = true;
            data->state = FlickData::Steady;
        }
        if (eventType == QEvent::MouseMove ||
            eventType == QEvent::GraphicsSceneMouseMove) {
            consumed = true;
            data->state = FlickData::ManualScroll;
            data->dragPos = QCursor::pos();
            if (!d->ticker.isActive())
                d->ticker.start(20, this);
        }
        break;

    default:
        break;
    }

    return consumed;
}

void FlickCharm::timerEvent(QTimerEvent *event)
{
    int count = 0;
    QHashIterator<QObject*, FlickData*> item(d->flickData);
    while (item.hasNext()) {
        item.next();
        FlickData *data = item.value();

        if (data->state == FlickData::ManualScroll) {
            count++;
            data->speed = QCursor::pos() - data->dragPos;
            data->dragPos = QCursor::pos();
        }

        if (data->state == FlickData::AutoScroll) {
            count++;
            data->speed = deaccelerate(data->speed);
            QPoint p = scrollOffset(data->widget);
            setScrollOffset(data->widget, p - data->speed);
            if (data->speed == QPoint(0, 0))
                data->state = FlickData::Steady;
        }
    }

    if (!count)
        d->ticker.stop();

    QObject::timerEvent(event);
}