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

/*
 W A R N I N G
 -------------
  THIS IS A TEMPORARY GESTURE CODE. WOULD BE REPLACED WHEN BROWSER HAS ITS OWN GESTURE FRAMEWORK
 */

#include "GestureRecognizer.h"

#include "GestureListener.h"
#include "GestureRecognizer_p.h"

#include <QtGui>

static const int DoubleClickFilterDuration = 300;
static const int LongClickFilterDuration = 1000;
static const int MinTimeHoldForClick = 50;
static const int ThresholdForMove = 30;

namespace GVA {

GestureRecognizer::GestureRecognizer(GestureListener* gestureListener)
    : d_ptr(new GestureRecognizerPrivate(gestureListener))
{
    Q_D(GestureRecognizer);
    d->q_ptr = this;
}

GestureRecognizer::~GestureRecognizer()
{ }

bool GestureRecognizer::mouseEventFilter(QGraphicsSceneMouseEvent* event)
{
    Q_D(GestureRecognizer);
    bool handled = false;

    switch(event->type()) {
    case QEvent::GraphicsSceneMouseDoubleClick:
        handled = d->mouseDoubleClickEvent(event);
        break;
    case QEvent::GraphicsSceneMouseMove:
        handled = d->mouseMoveEvent(event);
        break;
    case QEvent::GraphicsSceneMousePress:
        handled = d->mousePressEvent(event);
        break;
    case QEvent::GraphicsSceneMouseRelease:
        handled = d->mouseReleaseEvent(event);
        break;
    case QEvent::GraphicsSceneContextMenu:
        //Swallow context menu event.
        //Since we have own way of handling it
        handled = true;
    default:
        break;
    }
    return handled;
}

qreal GestureRecognizer::dragInertia() const
{
    Q_D(const GestureRecognizer);
    return d->m_dragInertia;
}

void GestureRecognizer::setDragInertia(qreal inertia)
{
    Q_D(GestureRecognizer);
    d->m_dragInertia = inertia;
}

int GestureRecognizer::directionErrorMargin() const
{
    Q_D(const GestureRecognizer);
    return d->m_directionErrorMargin;
}

void GestureRecognizer::setDirectionErrorMargin(int errorMargin)
{
    Q_D(GestureRecognizer);
    d->m_directionErrorMargin = errorMargin;
}

qreal GestureRecognizer::axisLockThreshold() const
{
    Q_D(const GestureRecognizer);
    return d->m_axisLockThreshold;
}

void GestureRecognizer::setAxisLockThreshold(qreal threshold)
{
    Q_D(GestureRecognizer);
    d->m_axisLockThreshold = threshold;
}

qreal GestureRecognizer::maximumVelocity() const
{
    Q_D(const GestureRecognizer);
    return d->m_maxVelocity;
}

void GestureRecognizer::setMaximumVelocity(qreal v)
{
    Q_D(GestureRecognizer);
    d->m_maxVelocity = v;
}

qreal GestureRecognizer::minimumVelocity() const
{
    Q_D(const GestureRecognizer);
    return d->m_minVelocity;
}

void GestureRecognizer::setMinimumVelocity(qreal v)
{
    Q_D(GestureRecognizer);
    d->m_minVelocity = v;
}

int GestureRecognizer::panningThreshold() const
{
    Q_D(const GestureRecognizer);
    return d->m_panningThreshold;
}

void GestureRecognizer::setPanningThreshold(int threshold)
{
    Q_D(GestureRecognizer);
    d->m_panningThreshold = threshold;
}

qreal GestureRecognizer::fastVelocityFactor() const
{
    Q_D(const GestureRecognizer);
    return d->m_fastVelocityFactor;
}

void GestureRecognizer::setFastVelocityFactor(qreal v)
{
    Q_D(GestureRecognizer);
    d->m_fastVelocityFactor = v;
}

int GestureRecognizer::scrollsPerSecond() const
{
    Q_D(const GestureRecognizer);
    return d->m_fastVelocityFactor;
}

void GestureRecognizer::setScrollsPerSecond(int sps)
{
    Q_D(GestureRecognizer);
    d->m_scrollsPerSecond = sps;
}

//
//GestureRecognizerPrivate DIFINITION
//
GestureRecognizerPrivate::GestureRecognizerPrivate(GestureListener* gestureListener)
    : m_gestureListener(gestureListener)
    , m_state(GestureRecognizerPrivate::Inactive)
    , m_dragInertia(0.85)
    , m_directionErrorMargin(10)
    , m_axisLockThreshold(0)
    , m_maxVelocity(3500)
    , m_minVelocity(10)
    , m_panningThreshold(25)
    , m_fastVelocityFactor(0.01)
    , m_scrollsPerSecond(20)
    , m_velocity(QPointF(0, 0))
    , m_position(QPointF(-1, -1))
    , m_initialPos(QPointF(-1, -1))

{ }

GestureRecognizerPrivate::~GestureRecognizerPrivate()
{ }

bool GestureRecognizerPrivate::mousePressEvent(QGraphicsSceneMouseEvent* event)
{
    if (event->button() != Qt::LeftButton)
        return false;

    if (m_state == GestureRecognizerPrivate::Inactive) {
        //First mouse press.
        m_position = event->scenePos();
        m_initialPos = m_position;

        changeState(GestureRecognizerPrivate::Press);

        GestureEvent gesture = gestureEvent(m_initialPos, GestureEvent::Touch);
        m_gestureListener->handleGesture(&gesture);

        m_lastTime.start();
        m_delayedPressMoment.start();
        m_timer.start(LongClickFilterDuration, this);
    } else if(m_state == GestureRecognizerPrivate::Release) {
        //This press is for double tap.
        changeState(GestureRecognizerPrivate::DoublePress);
    }
    event->setAccepted(true);
    return true;
}

bool GestureRecognizerPrivate::mouseReleaseEvent(QGraphicsSceneMouseEvent* event)
{
    if (event->button() != Qt::LeftButton)
        return true;

    if (m_state == GestureRecognizerPrivate::Inactive) {
        //Release event cannot be generated in gesture recognizer is in active!
        event->setAccepted(true);
        resetTouchPositions();
        return true;
    }

    if (m_state == GestureRecognizerPrivate::Press) {
        if (m_delayedPressMoment.elapsed() > MinTimeHoldForClick) {
            //Waiting for MinTimeHoldForClick to make sure use has actually pressed.
            //Removes accidentall press
            changeState(GestureRecognizerPrivate::Release);
            m_timer.start(DoubleClickFilterDuration, this);
        } else
            resetTouchPositions();
    } else if (m_state == GestureRecognizerPrivate::Move) {
        if (qAbs(m_velocity.x()) > m_minVelocity
            || qAbs(m_velocity.y()) > m_minVelocity) {
            GestureEvent gesture = gestureEvent(m_position, GestureEvent::Flick);
            gesture.setVelocity(m_velocity);
            m_gestureListener->handleGesture(&gesture);
        }
        m_velocity = QPointF(0,0);
        resetTouchPositions();
    } else if (m_state == GestureRecognizerPrivate::DoublePress) {
        //Stop double tap timer
        m_timer.stop();
        GestureEvent gesture = gestureEvent(m_initialPos, GestureEvent::DoubleTap);
        m_gestureListener->handleGesture(&gesture);
        resetTouchPositions();
    }
    event->setAccepted(true);
    return true;
}

bool GestureRecognizerPrivate::mouseMoveEvent(QGraphicsSceneMouseEvent* event)
{
    QPoint delta;
    if (m_state == GestureRecognizerPrivate::Press) {
        delta = (event->scenePos() - m_initialPos).toPoint();
        QPoint absDelta;
        absDelta.setX(qAbs(delta.x()));
        absDelta.setY(qAbs(delta.y()));

        if ((absDelta.x() > ThresholdForMove) || (absDelta.y() > ThresholdForMove)) {
            //Stop long tap timer
            m_timer.stop();

            changeState(GestureRecognizerPrivate::Move);
            m_position = event->scenePos();
        } else {
            //Ignore until user has actually moved
            return true;
        }
    } else if (m_state == GestureRecognizerPrivate::Move) {
        delta = (event->scenePos() - m_position).toPoint();
        m_position = event->scenePos();
    } else {
        resetTouchPositions();
        return true;
    }

    //Aplly if axis stickiness is specified.
    if (m_axisLockThreshold) {
        int dx = qAbs(delta.x());
        int dy = qAbs(delta.y());

        if (dx || dy) {
            bool vertical = (dy > dx);
            qreal alpha = qreal(vertical ? dx : dy) / qreal(vertical ? dy : dx);
            if (alpha <= m_axisLockThreshold) {
                if (vertical)
                    delta.setX(0);
                else
                    delta.setY(0);
            }
        }
    }

    m_velocity = calculateVelocity(delta, m_lastTime.elapsed());

    //Send pan gesture
    GestureEvent gesture = gestureEvent(m_position, GestureEvent::Pan);
    gesture.setDelta(delta);
    m_gestureListener->handleGesture(&gesture);
    m_lastTime.restart();

    event->setAccepted(true);
    return true;
}

bool GestureRecognizerPrivate::mouseDoubleClickEvent(QGraphicsSceneMouseEvent* event)
{
    if (m_state == GestureRecognizerPrivate::Release) {
        m_timer.stop();
        GestureEvent gesture = gestureEvent(m_initialPos, GestureEvent::DoubleTap);
        m_gestureListener->handleGesture(&gesture);
    }
    resetTouchPositions();
    event->setAccepted(true);
    return true;
}

void GestureRecognizerPrivate::changeState(GestureRecognizerPrivate::State state)
{
    m_state = state;
}

GestureEvent GestureRecognizerPrivate::gestureEvent(const QPointF& pos, GestureEvent::Type type)
{
    GestureEvent gestureEvent;
    gestureEvent.setType(type);
    gestureEvent.setPosition(pos);
    return gestureEvent;
}

void GestureRecognizerPrivate::timerEvent(QTimerEvent* event)
{
    if (event->timerId() != m_timer.timerId())
        return;

    m_timer.stop();

    QPointF position;
    GestureEvent::Type gestureType;

    if (m_state == GestureRecognizerPrivate::Press) {
        //Long press
        position = m_position;
        gestureType = GestureEvent::LongTap;
    } else if (m_state == GestureRecognizerPrivate::Release) {
        //Actual release event
        position = m_initialPos;
        gestureType = GestureEvent::Release;
    } else {
        resetTouchPositions();
        changeState(GestureRecognizerPrivate::Inactive);
        return;
    }

    resetTouchPositions();
    GestureEvent gesture = gestureEvent(position, gestureType);
    m_gestureListener->handleGesture(&gesture);
    return;
}

void GestureRecognizerPrivate::resetTouchPositions()
{
    m_position = QPointF(-1, -1);
    m_initialPos = m_position;
    changeState(GestureRecognizerPrivate::Inactive);
}

QPointF GestureRecognizerPrivate::calculateVelocity(const QPointF& delta, int time)
{
    QPointF newVelocity = m_velocity;

    if ((delta / qreal(time)).manhattanLength() < 25) {
        QPointF rawVelocity = delta / qreal(time) * qreal(1000) / qreal(m_scrollsPerSecond);
        newVelocity = newVelocity * (qreal(1) - m_dragInertia) + rawVelocity * m_dragInertia;
    }

    newVelocity.setX(delta.x() ? qBound(-m_maxVelocity, newVelocity.x(), m_maxVelocity) : m_velocity.x());
    newVelocity.setY(delta.y() ? qBound(-m_maxVelocity, newVelocity.y(), m_maxVelocity) : m_velocity.y());
    return newVelocity;
}

} // namespace GVA