////////////////////////////////////////////////////////////////////////
// kineticscroll.cpp                                                   //
//                                                                     //
// Copyright(C) 2009 Igor Trindade Oliveira <igor.oliveira@indt.org.br>//
// Copyright(C) 2009 Adenilson Cavalcanti <adenilson.silva@idnt.org.br>//
//                                                                     //
// This library 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; either        //
// version 2.1 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   //
// Lesser General Public License for more details.                     //
//                                                                     //
// You should have received a copy of the GNU Lesser General Public    //
// License along with this library; if not, write to the Free Software //
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA       //
// 02110-1301  USA                                                     //
/////////////////////////////////////////////////////////////////////////
#include <QtCore/qglobal.h>
#include <QtCore/qmetatype.h>
#include <QGraphicsScene>
#include <QGraphicsSceneMouseEvent>
#include <QGraphicsSceneWheelEvent>
#include <QTime>
#include <QGraphicsWidget>
#include <QPoint>
#include <QPropertyAnimation>
#include <QCursor>

#include <kdebug.h>

#include "kineticscroll_p.h"

/* TODO:
 * - clean up the code(remove duplicated code, constify)
 * - port to Plasma::Animator
 */

namespace Plasma
{

class KineticScrollingPrivate
{
public:
    enum Direction {
        None,
        Up,
        Down,
        Left,
        Right
    };

    enum Gesture {
        GestureNone = 0,
        GestureUndefined,
        GestureScroll,
        GestureZoom
    };

    KineticScrollingPrivate()
        : overshoot(20),
        hasOvershoot(true),
        parent(0),
        forwardingEvent(false),
        multitouchGesture(GestureNone)
    {
    }

    void count()
    {
        t = QTime::currentTime();
    }

    void syncViewportRect()
    {
        contentsSize = parent->property("contentsSize").toSizeF();
        viewportGeometry = parent->property("viewportGeometry").toRectF();
    }
    
    bool canScroll(Direction direction, bool hasOvershoot = false) const
    {
        QPointF scrollPosition = -parent->property("scrollPosition").value<QPointF>();
        int offset = (hasOvershoot?overshoot*2:0);

        switch (direction) {
        case Up:
            return (scrollPosition.y() < offset);
        case Down:
            return (scrollPosition.y() + contentsSize.height() + offset >= viewportGeometry.bottom());
        case Left:
            return (scrollPosition.x() < offset);
        case Right:
            return (scrollPosition.x() + contentsSize.width() + offset >= viewportGeometry.right());
        default:
            return true;
        }
    }


    QPointF kinMovement;

    enum BounceStatus {
        Running,
        Finished
    };

    BounceStatus bounceStatus;

    QPropertyAnimation *scrollAnimation;

    int overshoot;
    QPointF cposition;
    bool hasOvershoot;
    QGraphicsWidget *parent;
    QRectF viewportGeometry;
    QSizeF contentsSize;
    QPointF maximum, minimum;
    bool forwardingEvent;
    Gesture multitouchGesture;

    unsigned int timeDelta;
    QTime t;
};


KineticScrolling::KineticScrolling(QGraphicsWidget *parent)
    : d(new KineticScrollingPrivate)
{
    setWidget(parent);
}

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

void KineticScrolling::duration( )
{
    d->timeDelta = d->t.msecsTo(QTime::currentTime());
}

void KineticScrolling::overshoot()
{
    QPointF scrollPosition = -d->parent->property("scrollPosition").value<QPointF>();

    if (!d->canScroll(KineticScrollingPrivate::Down) &&
        !d->canScroll(KineticScrollingPrivate::Up)) {
        return;
    }

    if (d->bounceStatus != KineticScrollingPrivate::Running) {
        if ((d->cposition.y() > 0 ) || (d->cposition.y() <= d->minimum.y() + d->overshoot)) {
            QPointF finalPosition;
            d->scrollAnimation->setEasingCurve( QEasingCurve::OutBounce );

            if (d->cposition.y() > 0) {
                finalPosition = QPointF(scrollPosition.x(), 0);
            } else {
                finalPosition = QPointF(d->cposition.x(),
                        -d->contentsSize.height( ) + d->parent->size().height());
            }

            resetAnimation(-finalPosition, 900);
            d->bounceStatus = KineticScrollingPrivate::Running;
        }
    } else {
        d->bounceStatus = KineticScrollingPrivate::Finished;
        d->scrollAnimation->setEasingCurve(QEasingCurve::OutCirc);
    }
}

void KineticScrolling::setScrollValue(QPointF value)
{
    const QPointF pos = thresholdPosition(value);
    QPointF posf(-pos);
    d->parent->setProperty("scrollPosition", posf);

    if ((pos.y() == d->overshoot) || (pos.y() == d->minimum.y())) {
        overshoot();
    }
}

QPointF KineticScrolling::thresholdPosition(QPointF value) const
{
    d->minimum.setX(-d->contentsSize.width() + d->viewportGeometry.width());
    d->minimum.setY(-d->contentsSize.height() + d->viewportGeometry.height()
        -d->overshoot);

    d->minimum.setY(qMin((qreal)d->overshoot, d->minimum.y()));
    d->maximum = value;

    if(d->minimum.x() >= 0) {
        d->cposition.setX(value.x());
    } else {
        d->cposition.setX(qBound(d->minimum.x(), d->maximum.x(), qreal(0)));
    }

    if((-d->contentsSize.height() + d->viewportGeometry.height() - d->overshoot) >= 0) {
        d->cposition.setY(value.y());
    } else {
        d->cposition.setY(qBound(d->minimum.y(), d->maximum.y(), qreal(d->overshoot)));
    }

    return d->cposition;
}

void KineticScrolling::resetAnimation(QPointF finalPosition, int duration)
{
    if (d->scrollAnimation->state() != QAbstractAnimation::Stopped) {
        d->scrollAnimation->stop();
    }

    d->cposition = -finalPosition;
    QPointF tmpPosition = d->parent->property("scrollPosition").value<QPointF>();
    d->scrollAnimation->setStartValue(tmpPosition);

    tmpPosition = finalPosition;

    d->scrollAnimation->setEndValue(tmpPosition);
    d->scrollAnimation->setDuration(duration);
    d->scrollAnimation->start();

}

void KineticScrolling::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    if (d->scrollAnimation->state() != QAbstractAnimation::Stopped) {
        d->scrollAnimation->stop();
    }

    d->syncViewportRect();
    d->cposition = -d->parent->property("scrollPosition").value<QPointF>();

    if (event && d->cposition == QPointF(0, 0) &&
            d->viewportGeometry.width() + 2 >= d->contentsSize.width() &&
            d->viewportGeometry.height() + 2 >= d->contentsSize.height()) {
        event->ignore( );
    }

    d->count();
    d->kinMovement = QPointF(0,0);
    d->scrollAnimation->setEasingCurve(QEasingCurve::OutCirc);
}

void KineticScrolling::mouseMoveEvent(QGraphicsSceneMouseEvent *event)
{
    QPointF movement = event->lastPos().toPoint() - event->pos().toPoint();
    const QPointF scrollPosition = -d->parent->property("scrollPosition").value<QPointF>();

    if (!movement.isNull()) {
        if ((d->contentsSize.width() < d->viewportGeometry.width()) &&
                (d->contentsSize.height() < d->viewportGeometry.height())) {
            d->kinMovement = QPointF(0, 0);
            movement = QPointF(0, 0);
        } else if (d->contentsSize.height() < d->viewportGeometry.height()) {
            d->kinMovement += QPointF(movement.x(), 0);
            movement.setY(0);
        } else if (d->contentsSize.width() < d->viewportGeometry.width()) {
            d->kinMovement = QPointF(0, movement.y());
            movement.setX(0);
        } else {
            d->kinMovement += movement;
        }
        setScrollValue(scrollPosition - movement);
    }
}

void KineticScrolling::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
{
    Q_UNUSED(event);

    if (d->scrollAnimation->state() != QAbstractAnimation::Running) {
        duration();

        if (d->kinMovement != QPointF(0, 0)) {
            const QPointF scrollPosition = -d->parent->property("scrollPosition").toPointF();
            d->kinMovement = QPointF(d->kinMovement.x()*3, d->kinMovement.y()*3);
            const QPointF finalPos = thresholdPosition(scrollPosition - d->kinMovement);
            resetAnimation( -finalPos, d->timeDelta*8 );
        }
    }
}

void KineticScrolling::wheelReleaseEvent(QGraphicsSceneWheelEvent *event)
{
    Q_UNUSED(event);
    d->syncViewportRect();
    d->kinMovement = QPointF(0,0);

    if((event->orientation() == Qt::Vertical) &&
       ((event->delta() < 0) && d->canScroll(KineticScrollingPrivate::Down) ||
       (event->delta() > 0) && d->canScroll(KineticScrollingPrivate::Up))) {
        d->kinMovement.setY(d->kinMovement.y() - event->delta());
    } else if ((event->orientation() == Qt::Vertical) ||
               (!d->canScroll(KineticScrollingPrivate::Down) &&
               !d->canScroll(KineticScrollingPrivate::Up))) {
        if (((event->delta() < 0) &&
            d->canScroll(KineticScrollingPrivate::Right)) ||
            (event->delta() > 0 && d->canScroll(KineticScrollingPrivate::Left))) {
            d->kinMovement.setX(d->kinMovement.x() - event->delta());
        } else {
            event->ignore( );
        }
    } else {
        event->ignore( );
        return;
    }

    const QPointF scrollPosition = -d->parent->property("scrollPosition").value<QPointF>();
    const QPointF pos = scrollPosition - d->kinMovement*2;
    const QPointF finalPos = thresholdPosition(pos);

    d->scrollAnimation->setEasingCurve(QEasingCurve::OutCirc);
    resetAnimation(-finalPos, 900);
}

void KineticScrolling::keyPressEvent(QKeyEvent *event)
{
    const int movement = 30;
    const int duration = 900;

    QPointF scrollPosition = -d->parent->property("scrollPosition").value<QPointF>();
    QPointF finalPos;
    switch (event->key()) {
    case Qt::Key_Left:
        scrollPosition.setX(scrollPosition.x() + movement);
        finalPos = thresholdPosition(scrollPosition);
        resetAnimation(-finalPos, duration);
        break;
    case Qt::Key_Right:
        scrollPosition.setX(scrollPosition.x() - movement);
        finalPos = thresholdPosition(scrollPosition);
        resetAnimation(-finalPos, duration);
        break;
    case Qt::Key_Up:
        scrollPosition.setY(scrollPosition.y() + movement);
        finalPos = thresholdPosition(scrollPosition);
        resetAnimation(-finalPos, duration);
        break;
    case Qt::Key_Down:
        scrollPosition.setY(scrollPosition.y() - movement);
        finalPos = thresholdPosition(scrollPosition);
        resetAnimation(-finalPos, duration);
        break;
    default:
        break;
    }
}

void KineticScrolling::setWidget(QGraphicsWidget *parent)
{
    if (d->parent) {
        d->parent->removeEventFilter(this);
        disconnect(d->scrollAnimation, SIGNAL(finished()), this, SLOT(overshoot()));
        delete d->scrollAnimation;
    }

    setParent(parent);

    d->parent = parent;

    d->scrollAnimation = new QPropertyAnimation(parent, "scrollPosition", parent);
    connect(d->scrollAnimation, SIGNAL(finished()), this, SLOT(overshoot()));
    d->scrollAnimation->setEasingCurve(QEasingCurve::OutCirc);

    if (parent) {
        d->parent->installEventFilter(this);
    }
    /* TODO: add a new property in plasma::ScrollWidget 'hasOvershoot' */
}

bool KineticScrolling::eventFilter(QObject *watched, QEvent *event)
{
    Q_UNUSED(watched);
    Q_UNUSED(event);

    if (d->forwardingEvent) {
        return false;
    }

    bool notBlocked = true;
    if (d->multitouchGesture == KineticScrollingPrivate::GestureNone &&
            d->parent && d->parent->scene()) {
        d->forwardingEvent = true;
        notBlocked = d->parent->scene()->sendEvent(d->parent, event);
        d->forwardingEvent = false;
    }

   if (event->type() != QEvent::TouchBegin &&
       event->type() != QEvent::TouchUpdate &&
       event->type() != QEvent::TouchEnd &&
       (!notBlocked ||
       ((event->type() != QEvent::GraphicsSceneMousePress && event->isAccepted()) &&
        (event->type() != QEvent::GraphicsSceneWheel && event->isAccepted())))) {
       return true;
   }

    QGraphicsSceneMouseEvent *me = static_cast<QGraphicsSceneMouseEvent *>(event);
    QGraphicsSceneWheelEvent *we = static_cast<QGraphicsSceneWheelEvent *>(event);

    switch (event->type()) {
    case QEvent::GraphicsSceneMousePress:
        mousePressEvent(me);
        break;
    case QEvent::GraphicsSceneMouseRelease:
        mouseReleaseEvent(me);
        break;
    case QEvent::GraphicsSceneMouseMove:
        mouseMoveEvent(me);
        break;
    case QEvent::TouchBegin:
        mousePressEvent(0);
        break;
    case QEvent::TouchUpdate: {
        QList<QTouchEvent::TouchPoint> touchPoints = static_cast<QTouchEvent *>(event)->touchPoints();
        if (touchPoints.count() == 2) {
            const QTouchEvent::TouchPoint &touchPoint0 = touchPoints.first();
            const QTouchEvent::TouchPoint &touchPoint1 = touchPoints.last();
            const QLineF line0(touchPoint0.lastPos(), touchPoint1.lastPos());
            const QLineF line1(touchPoint0.pos(), touchPoint1.pos());
            const QLineF startLine(touchPoint0.startPos(), touchPoint1.startPos());
            const QPointF point = line1.pointAt(0.5);
            const QPointF lastPoint = line0.pointAt(0.5);

            if (d->multitouchGesture == KineticScrollingPrivate::GestureNone) {
                d->multitouchGesture = KineticScrollingPrivate::GestureUndefined;
            }
            if (d->multitouchGesture == KineticScrollingPrivate::GestureUndefined) {
                const int zoomDistance = qAbs(line1.length() - startLine.length());
                const int dragDistance = (startLine.pointAt(0.5) - point).manhattanLength();

                if (zoomDistance - dragDistance > 30) {
                    d->multitouchGesture = KineticScrollingPrivate::GestureZoom;
                } else if (dragDistance - zoomDistance > 30) {
                    d->multitouchGesture = KineticScrollingPrivate::GestureScroll;
                }
            }

            if (d->multitouchGesture ==  KineticScrollingPrivate::GestureScroll) {
                QGraphicsSceneMouseEvent fakeEvent;
                fakeEvent.setPos(point);
                fakeEvent.setLastPos(lastPoint);
                mouseMoveEvent(&fakeEvent);
            } else if (d->multitouchGesture == KineticScrollingPrivate::GestureZoom) {
                qreal scaleFactor = 1;
                if (line0.length() > 0) {
                    scaleFactor = line1.length() / line0.length();
                }

                qreal zoom = d->parent->property("zoomFactor").toReal();
                d->parent->setProperty("zoomFactor", zoom * scaleFactor);
            }
        }
        break;
    }
    case QEvent::TouchEnd:
        mouseReleaseEvent(0);
        d->multitouchGesture = KineticScrollingPrivate::GestureNone;
        break;

    case QEvent::GraphicsSceneWheel:
        wheelReleaseEvent(we);
        break;
    case QEvent::KeyPress: {
        QKeyEvent *ke = static_cast<QKeyEvent *>(event);
        keyPressEvent(ke);
        break;
    }
    default:
        break;
    }

    return true;
}

} // namespace Plasma