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

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
*/

#include "config.h"
#include "TouchGestureHandler.h"

#include <math.h>

#ifndef M_PI
#define M_PI 3.1415926536
#endif

namespace WebCore {

TouchGestureHandler::TouchGestureHandler()
{
    reset();
}

void TouchGestureHandler::updateRefreshNeededState(const Vector<const PlatformTouchPoint*>& touchPoints)
{
    // Number of touchpoints changed
    if (touchPoints.size() != m_prevSize)
        m_refreshNeeded = true;
    else {
        for (int i = 0; i < touchPoints.size(); ++i) {
            // Touchpoints in pressed state or ids mismatch
            if (touchPoints[i]->state() == PlatformTouchPoint::TouchPressed
                || touchPoints[i]->id() != m_prevIds[i]) m_refreshNeeded = true;
        }
    }

    m_prevSize = touchPoints.size();
    for (int i = 0; i < touchPoints.size(); ++i)
        m_prevIds[i] = touchPoints[i]->id();
}

void TouchGestureHandler::updateTouchPoints(const Vector<const PlatformTouchPoint*>& touchPoints)
{
    if (touchPoints.isEmpty())
        return;

    updateRefreshNeededState(touchPoints);

    if (m_refreshNeeded) {
        m_pos = calcPos(touchPoints);
        IntSize clientOffset = touchPoints[0]->screenPos() - touchPoints[0]->pos();
        m_screenPos = m_pos + clientOffset;

        if (touchPoints.size() > 1) {
            m_prevAngle = calcAngle(touchPoints[0]->pos(), touchPoints[1]->pos());
            m_prevDistance = calcDistance(touchPoints[0]->pos(), touchPoints[1]->pos());
        }
        m_refreshNeeded = false;
        return;
    }

    // Pan
    IntPoint nextPos = calcPos(touchPoints);
    m_translate += (nextPos - m_pos);
    m_pos = nextPos;
    IntSize clientOffset = touchPoints[0]->screenPos() - touchPoints[0]->pos();
    m_screenPos = m_pos + clientOffset;

    if (touchPoints.size() > 1) {
        // Rotate
        float angle = calcAngle(touchPoints[0]->pos(), touchPoints[1]->pos());
        m_rotate += diffAngle(m_prevAngle, angle);
        m_prevAngle = angle;

        // Pinch
        float distance = calcDistance(touchPoints[0]->pos(), touchPoints[1]->pos());
        float nextScale = m_scale * (distance / (m_prevDistance ? m_prevDistance : 0.0001f));
        m_scale = nextScale;
        m_prevDistance = distance;
    }
}

void TouchGestureHandler::reset()
{
    m_refreshNeeded = true;
    m_scale = 1.0;
    m_rotate = 0;
    m_translate = IntPoint(0, 0);
    m_pos = IntPoint(0, 0);
    m_screenPos = IntPoint(0, 0);
    m_prevSize = 0;
}

float TouchGestureHandler::calcAngle(const IntPoint& p1, const IntPoint& p2) const
{
    float deltaX = p1.x() - p2.x();
    float deltaY = p1.y() - p2.y();
    return atan2(deltaY, deltaX);
}

float TouchGestureHandler::diffAngle(float alpha, float beta) const
{
    float between = beta - alpha;

    if (between > M_PI)
        between -= 2 * M_PI;
    else if (between < -M_PI)
        between += 2 * M_PI;

    return between;
}

IntPoint TouchGestureHandler::calcPos(const Vector<const PlatformTouchPoint*>& touchPoints) const
{
    if (touchPoints.size() == 1)
        return touchPoints[0]->pos();

    IntPoint pos;
    pos.setX((touchPoints[0]->pos().x() + touchPoints[1]->pos().x()) / 2);
    pos.setY((touchPoints[0]->pos().y() + touchPoints[1]->pos().y()) / 2);
    return pos;
}

float TouchGestureHandler::calcDistance(const IntPoint& p1, const IntPoint& p2) const
{
    float dx = p1.x() - p2.x();
    float dy = p1.y() - p2.y();
    return sqrt(dx * dx + dy * dy);
}

}