#include <QtCore>

#include "ScrollHelper.h"

#include "qstmfilelogger.h"

#define SCROLL_TIMEOUT   16

namespace GVA

{

static const int MaxFlickDurartion = 1500;

static const int MidFlickDurartion = 800;

static const int MinFlickDurartion = 500;

static const qreal MaxFlickSpeed = 2.0;

static const qreal MidFlickSpeed = 1.2;

static const qreal MinFlickSpeed = 0.5;

static const qreal MaxFlickInViewportUnits = 1.0;

static const qreal MidFlickInViewportUnits = 0.8;

static const qreal MinFlickInViewportUnits = 0.2;

static const qreal DefaultDecel = 0.005;

ScrollHelper::ScrollHelper(QObject* scrolledWidget) : QObject(),

                                  m_scrolledWidget(scrolledWidget),

                                  m_minFlickDuration(MinFlickDurartion),

                                  m_maxFlickDuration(MaxFlickDurartion),

                                  m_midFlickDuration(MidFlickDurartion),

                                  m_scrollDelta(QPointF()),

                                  m_minFlickSpeed(MinFlickSpeed),

                                  m_maxFlickSpeed(MaxFlickSpeed),

                                  m_midFlickSpeed(MidFlickSpeed),

                                  m_maxFlickInViewportUnits(MaxFlickInViewportUnits),

                                  m_minFlickInViewportUnits(MinFlickInViewportUnits),

                                  m_midFlickInViewportUnits(MidFlickInViewportUnits),

                                  m_viewportSize(QSize()),

                                  m_lockToY(false),

                                  m_lockToX(false),

                                  m_decel(DefaultDecel)

{

    m_scrollAnimation = new QPropertyAnimation(scrolledWidget, "widgetScrollPosition");

    connect(m_scrollAnimation, SIGNAL(finished()), this, SLOT(stopScroll()));

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

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

    m_scrollTimer = UiTimer::New();    

    m_scrollTimer->setPriority(50);   

    m_scrollTimer->setTimerCallback("scrollTimerCallback");

    m_easingCurve = new QEasingCurve(QEasingCurve::OutCubic);

    m_easingCurveOvershoot= new QEasingCurve(QEasingCurve::OutBack);

}

ScrollHelper::~ScrollHelper()

{

    m_scrollTimer->stop();

    delete m_scrollTimer;

    delete m_easingCurve;

    delete m_easingCurveOvershoot;

}

void ScrollHelper::setFlickDurationLimits(int minDuration, int midDuration, int maxDuration)

{

    m_minFlickDuration = minDuration;

    m_midFlickDuration = midDuration;

    m_maxFlickDuration = maxDuration;

}

void ScrollHelper::setFlickSpeedLimits(qreal minSpeed, qreal midSpeed, qreal maxSpeed)

{

    m_minFlickSpeed = minSpeed;

    m_midFlickSpeed = midSpeed;

    m_maxFlickSpeed = maxSpeed;

}

void ScrollHelper::setFlickLimits(qreal minFlick, qreal midFlick, qreal maxFlick)

{

    m_minFlickInViewportUnits = minFlick;

    m_midFlickInViewportUnits = midFlick;

    m_maxFlickInViewportUnits = maxFlick;

}

void ScrollHelper::setDeceleration(qreal decel)

{

    m_decel = decel;

}

qreal ScrollHelper::getDeceleration()

{

    return m_decel;

}

void ScrollHelper::scrollTimerCallback()

{

    m_scrollTimer->stop();

    if (m_scrollState != ScrollHelper::ActiveState) {

        return;

    }

    qstmDebug() << "ScrollHelper::scrollTimerCallback. m_scrollDelta: " << m_scrollDelta <<

            ", m_scrollMode: " << m_scrollMode << "\n";

    QPointF speed = m_kineticSpeed;

    if (m_scrollMode == ScrollHelper::KineticScrollMode) {

        m_scrollDuration += SCROLL_TIMEOUT;

        qreal progress = (qreal)m_scrollDuration / m_scrollTotalDuration;

        if (progress > 0.0 && progress < 1.0) {

            qreal val = m_curEasingCurve->valueForProgress(progress);

            QPointF tp = m_startScrollPos + val * (m_targetScrollPos - m_startScrollPos);

            m_curScrollPos = tp;

            setScrollPos(tp);

            m_scrollTimer->start(SCROLL_TIMEOUT, this);

        }

        else {

            stopScroll();

        }

    }

    else if (m_scrollMode == ScrollHelper::PanScrollMode) {

        doScroll(m_scrollDelta);

        m_scrollDelta = QPointF();

        m_scrollTimer->start(SCROLL_TIMEOUT, this);

    }

}

QPointF ScrollHelper::speedForNextInterval(const QPointF& initSpeed, long timeInterval, const QPointF& decel)

{

    QPointF speed = initSpeed;

    if (speed.y() < 0) {

        speed.ry() += (decel.y() * timeInterval);

        speed.ry() = qMin(qreal(0.0), speed.y());

    }

    else if (speed.y() > 0) {

        speed.ry() -= (decel.y() * timeInterval);

        speed.ry() = qMax(qreal(0.0), speed.y());

    }

    if (speed.x() < 0) {

        speed.rx() += (decel.x() * timeInterval);

        speed.rx() = qMin(qreal(0.0), speed.x());

    }

    else if (speed.x() > 0) {

        speed.rx() -= (decel.x() * timeInterval);

        speed.rx() = qMax(qreal(0.0), speed.x());

    }

    return speed;

}

void ScrollHelper::scroll(QPointF& delta)

{

    if ( delta.x() == 0 && delta.y() == 0)  return;

    if (m_scrollState == ScrollHelper::IdleState) {

        //m_lockToX = (delta.y() == 0);

        //m_lockToY = (delta.x() == 0);

        doScroll(delta);

        m_scrollDelta = QPointF();

        m_scrollTimer->setSingleShot(true);

        m_scrollTimer->start(SCROLL_TIMEOUT, this);

    }

    else {

        if (m_lockToX) {

            delta.ry() = 0.0;

        }

        if (m_lockToY) {

            delta.rx() = 0.0;

        }

        m_scrollDelta += delta;

    }

    m_scrollMode = ScrollHelper::PanScrollMode;

    m_scrollState = ScrollHelper::ActiveState;

}

bool ScrollHelper::isScrolling()

{

    return m_scrollState == ScrollHelper::ActiveState;

}

void ScrollHelper::doScroll(QPointF& delta)

{

    QPointF scrollPos = getScrollPos();

    QPointF targetPos;

    targetPos = scrollPos + delta;

    setScrollPos(targetPos);

}

QPointF ScrollHelper::getScrollPos()

{

    return m_scrolledWidget->property("widgetScrollPosition").toPointF();

}

void  ScrollHelper::setScrollPos(QPointF& pos)

{

     m_scrolledWidget->setProperty("widgetScrollPosition", pos.toPoint());

}

QPointF ScrollHelper::getMaxScrollPos()

{

    return m_scrolledWidget->property("maxScrollPosition").toPointF();

}

QSizeF ScrollHelper::viewportSize()

{

    return m_viewportSize;

}

void ScrollHelper::setViewportSize(const QSizeF& size)

{

    m_viewportSize = size;

}

void ScrollHelper::stopScrollNoSignal()

{

    m_scrollTimer->stop();

    reset();    

}

void ScrollHelper::stopScroll()

{     

    stopScrollNoSignal();

    emit scrollFinished();

}

void ScrollHelper::reset()

{

    m_scrollState = ScrollHelper::IdleState;

    m_scrollMode = ScrollHelper::ReadyMode;

    m_scrollDelta = QPointF();

    m_lockToY = false;

    m_lockToX = false;

}

void ScrollHelper::panFromOvershoot()

{

    stopScroll();

    QPointF scrollPos = getScrollPos();

    QPointF targetScrollPos = scrollPos;

    QEasingCurve::Type easingCurveType = QEasingCurve::OutCubic;

    if (clampScrollPosition(targetScrollPos)) {

        easingCurveType = QEasingCurve::OutBack;

        m_scrollMode = ScrollHelper::PanScrollMode;

        startScrollAnimation(scrollPos, targetScrollPos, 300, easingCurveType);

    }

}

bool ScrollHelper::clampScrollPosition(QPointF& scrollPos)

{

    QPointF maxScrollPos = getMaxScrollPos();

    QPointF origPos = scrollPos;

    scrollPos.ry() = qBound(qreal(0.0), origPos.y(), maxScrollPos.y());

    scrollPos.rx() = qBound(qreal(0.0), origPos.x(), maxScrollPos.x());

    bool clampY = (scrollPos.y() != origPos.y()) &&

                  (scrollPos.y() == qreal(0.0) || scrollPos.y() == maxScrollPos.y());

    bool clampX = (scrollPos.x() != origPos.x()) &&

                   (scrollPos.x() == qreal(0.0) || scrollPos.x() == maxScrollPos.x());

    return (clampX || clampY);

}

void ScrollHelper::startScrollAnimation(QPointF& scrollPos, QPointF& targetPos,

                                        int duration, QEasingCurve::Type& easingCurveType)

{

    if (scrollPos != targetPos) {

        m_scrollAnimation->setStartValue(scrollPos);

        m_scrollAnimation->setEndValue(targetPos);

        m_scrollAnimation->setDuration(duration);

        m_scrollAnimation->setEasingCurve(easingCurveType);

        m_scrollAnimation->start();

        m_scrollState = ScrollHelper::ActiveState;

    }

}

void ScrollHelper::scrollAnimationStateChanged(QAbstractAnimation::State newState,

                                               QAbstractAnimation::State)

{

    switch (newState) {

        case QAbstractAnimation::Stopped:

            reset();

            break;

        case QAbstractAnimation::Running:

            break;

        default:

            break;

    }

}

int ScrollHelper::calcScrollDuration(const QPointF& speed, const QPointF& delta)

{

    QPointF v1 = speed;

    int flickDuration = sqrt(delta.x() * delta.x() + delta.y() * delta.y()) /

                        sqrt(v1.x() * v1.x() + v1.y() * v1.y());

    flickDuration = qBound(m_minFlickDuration, flickDuration, m_maxFlickDuration);

    return flickDuration;

}

int ScrollHelper::calcScrollDuration(qreal motionFactor)

{

    int duration = m_midFlickDuration;

    if (motionFactor == m_maxFlickInViewportUnits) {

         duration = m_maxFlickDuration;

    }

    else if (motionFactor == m_minFlickInViewportUnits) {

        duration = m_minFlickDuration;

    }

    return duration;

}

void ScrollHelper::kineticScroll(QPointF& speed)

{

    if (m_lockToY) {

        speed.rx() = 0.0;

    }

    if (m_lockToX) {

        speed.ry() = 0.0;

    }

    //doScroll(m_scrollDelta);

    //stopScroll();

    QEasingCurve::Type easingCurveType = QEasingCurve::InOutCubic;

    QPointF scrollPos = getScrollPos() + m_scrollDelta;

    int flickDuration = 0;

    QPointF targetPos = calcTargetScrollPosAndDuration(speed, scrollPos, flickDuration);

    QPointF delta = targetPos - scrollPos;

    m_curEasingCurve = m_easingCurve;

    if (clampScrollPosition(targetPos)) {

        easingCurveType = QEasingCurve::OutBack;

        m_curEasingCurve = m_easingCurveOvershoot;

    }

    m_scrollMode = ScrollHelper::KineticScrollMode;

    qstmDebug() << "ScrollHelper::kineticScroll. initial speed: " << speed <<

            ", delta: " << delta <<

            ", flickDuration: " << flickDuration <<

            ", m_scrollDelta: " << m_scrollDelta << "\n";

    m_targetScrollPos = targetPos;

    m_kineticSpeed = speed;

    m_curScrollPos = scrollPos;

    m_startScrollPos = scrollPos;

    m_scrollTotalDuration = flickDuration;

    m_scrollDuration = 0; 

    m_lockToX = false;

    m_lockToY = false;

    //m_decelVec = calcTargetScrollPosAndDuration(speed, delta, flickDuration);

    //startScrollAnimation(scrollPos, targetPos, flickDuration, easingCurveType);

}

QPointF ScrollHelper::calcDeceleration(const QPointF& initSpeed, const QPointF& distance, long time)

{

    return 2 * (initSpeed * time - distance) / (time * time);

}

QPointF ScrollHelper::calcTargetScrollPosAndDuration(const QPointF& speed, const QPointF& scrollPos, int& duration)

{

    QSizeF  vpSize = viewportSize();

    QPointF targetPos = scrollPos;

    if (vpSize.isValid()) {

        qreal kX = 0.0;

        qreal kY = 0.0;

        if (speed.x() != 0.0) {

            kX = calcMotionFactor(speed.x());

        }

        if (speed.y() != 0.0) {

            kY = calcMotionFactor(speed.y());

        }

        targetPos.rx() -= kX * vpSize.width();

        targetPos.ry() -= kY * vpSize.height();

        duration = calcScrollDuration(qMax(qAbs(kX), qAbs(kY)));

    }

    return targetPos;

}

qreal ScrollHelper::calcMotionFactor(const qreal speed)

{

    qreal k = 0.0;

    qreal absSpeed = qAbs(speed);

    if (absSpeed >= m_maxFlickSpeed) {

        k = m_maxFlickInViewportUnits;

    }

    else if (absSpeed < m_maxFlickSpeed && absSpeed >= m_midFlickSpeed) {

        k = m_midFlickInViewportUnits;

    }

    else {

        k = m_minFlickInViewportUnits;

    }

    if (speed < 0) {

        k = -k;

    }

    return k;

}

}