/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:    

*

*/

#include "hgmediawallrenderer.h"

#include "hgmediawalldataprovider.h"

#include "hgquadrenderer.h"

#include "hgquad.h"

#include "hgimage.h"

#include "hgvgquadrenderer.h"

#include "hgqtquadrenderer.h"

#include <QVector3D>

#include <QTimer>

#include <QPropertyAnimation>

#include <QState>

#include <QAbstractTransition>

#include <QStateMachine>

#include <QSignalTransition>

#include <QSequentialAnimationGroup>

#include <QParallelAnimationGroup>

#include <QVariantAnimation>

#include <QPolygon>

#include <QPainter>

#include <QPaintEngine>

const qreal KPi = 3.1415926535897932384626433832795;

static qreal lerp(qreal start, qreal end, qreal t)

{

    return start * (1.0f - t) + end * t;

}

class MyVectorAnimation : public QVariantAnimation

{

public:

    virtual void updateCurrentValue(const QVariant& value)

    {

        mValue = value.value<QVector3D>();

    }

    QVector3D getValue() const

    {

        return mValue;

    }

private:

    QVector3D mValue;

};

class MyQuaternionAnimation : public QVariantAnimation

{

public:

    virtual void updateCurrentValue(const QVariant& value)

    {

        mValue = value.value<QQuaternion>();

    }

    QQuaternion getValue() const

    {

        return mValue;

    }

private:

    QQuaternion mValue;

};

class HgAnimatedQuad

{

public:

    static HgAnimatedQuad* createScrollDirectionChangeAnimation(

        HgQuad* a, HgQuad* b, const QMatrix4x4& tm, const QMatrix4x4& rm, 

        const QQuaternion& rot, Qt::Orientation orientation, 

        int duration)

    {

        HgAnimatedQuad* q = new HgAnimatedQuad();

        q->mQuad = a;

        q->mPosition.setEasingCurve(QEasingCurve::InOutCubic);

        q->mPosition.setDuration(duration);

        QVector3D pos = tm * (a->position() * rm);

        q->mPosition.setKeyValueAt(0, pos);

        QVector3D pos2;

        if (orientation == Qt::Horizontal)

        {

            pos2 = QVector3D(pos.x(), 0, pos.z() + (pos.y() > b->position().y() ? -0.5f : -0.5f));

        }

        else

        {

            pos2 = QVector3D(0, pos.y(), pos.z() + (pos.x() > b->position().x() ? -0.5f : -0.5f));            

        }

        q->mPosition.setKeyValueAt(0.5f, pos2);

        q->mPosition.setKeyValueAt(1, b->position());

        q->mRotation.setEasingCurve(QEasingCurve::InOutCubic);

        q->mRotation.setDuration(duration);

        q->mRotation.setKeyValueAt(0, rot);

        q->mRotation.setKeyValueAt(0.5f, QQuaternion::fromAxisAndAngle(QVector3D(1,1,0), 180));

        q->mRotation.setKeyValueAt(1, b->rotation());

        return q;

    }

    static HgAnimatedQuad* createBasicAnimation(HgQuad* a, HgQuad* b, int duration)

    {

        HgAnimatedQuad* q = new HgAnimatedQuad();

        q->mQuad = a;

        q->mPosition.setDuration(duration);

        q->mPosition.setKeyValueAt(0, a->position());

        q->mPosition.setKeyValueAt(1, b->position());

        q->mRotation.setDuration(duration);

        q->mRotation.setKeyValueAt(0, a->rotation());

        q->mRotation.setKeyValueAt(1, b->rotation());        

        return q;

    }

    void start()

    {

        mPosition.start();

        mRotation.start();

    }

    void update()

    {

        mQuad->setPosition(mPosition.currentValue().value<QVector3D>());

        mQuad->setRotation(mRotation.currentValue().value<QQuaternion>());

    }

    const HgQuad* quad() const

    {

        return mQuad;

    }

private:

    HgQuad* mQuad;

    MyVectorAnimation mPosition;

    //MyVectorAnimation mScale;

    MyQuaternionAnimation mRotation;

};

class HgAnimatedQuadFactory

{

public:

    virtual HgAnimatedQuad* createQuad(HgQuad* qA, HgQuad* qB) const=0;

};

class HgScrollDirChangeQuadFactory : public HgAnimatedQuadFactory

{

public:

    void setup(Qt::Orientation nextScrollDirection, 

        const QRectF& rect, const QSizeF& spacing, const QSizeF& size, 

        int duration)

    {

        mNextScrollDirection = nextScrollDirection;

        mDuration = duration;

        if (mNextScrollDirection == Qt::Horizontal)

        {

            qreal stepY = spacing.height() + size.height();

            qreal posY = 0.5f - (rect.height() / rect.width() / 2.0 - stepY / 2.0);                

            tm.translate(-posY,0);

            rm.rotate(-90, QVector3D(0,0,1));

            rot = QQuaternion::fromAxisAndAngle(QVector3D(0,0,1), 90);

        }

        else if (mNextScrollDirection == Qt::Vertical)

        {

            tm.translate(0,0.5f);

            rm.rotate(90, QVector3D(0,0,1));

            rot = QQuaternion::fromAxisAndAngle(QVector3D(0,0,1), -90);                

        }

    }

    HgAnimatedQuad* createQuad(HgQuad* qA, HgQuad* qB) const

    {

        return HgAnimatedQuad::createScrollDirectionChangeAnimation(qA, qB, 

            tm, rm, rot, mNextScrollDirection, mDuration);        

    }

private:

    QMatrix4x4 tm;

    QMatrix4x4 rm;

    QQuaternion rot;

    Qt::Orientation mNextScrollDirection;

    int mDuration;

};

class HgRowCountChangeQuadFactory : public HgAnimatedQuadFactory

{

public:

    HgRowCountChangeQuadFactory(int duration) : mDuration(duration)

    {

    }

    HgAnimatedQuad* createQuad(HgQuad* qA, HgQuad* qB) const

    {

        return HgAnimatedQuad::createBasicAnimation(qA, qB, mDuration);

    }

private:

    int mDuration;

};

HgMediaWallRenderer::HgMediaWallRenderer(HgMediaWallDataProvider* provider, 

    Qt::Orientation orientation, Qt::Orientation scrollDirection, bool coverflowMode) :

    mDataProvider(provider),

    mRenderer(NULL),

    mIndicatorRenderer(NULL),

    mRendererInitialized(false),

    mScrollDirection(scrollDirection),

    mNextScrollDirection(scrollDirection),

    mOrientation(orientation),

    mStateAnimationAlpha(0),

    mStateAnimationOnGoing(false),

    mAnimationAlpha(0),

    mCoverflowMode(coverflowMode),

    mRowCount(1),

    mNextRowCount(1),

    mStateAnimationDuration(500),

    mStep(1.1),

    mZfar(-2),

    mSpacing2D(10,10),

    mImageSize2D(100, 60),

    mCameraDistance(0),

    mCameraRotationY(0),

    mCameraRotationZ(0),

    mFrontCoverElevation(0.4),

    mFrontItemPosition(0,0)

{

    createStateMachine();

    mRenderer = new HgQtQuadRenderer(128);

    mRenderer->enableReflections(true);

    mRendererInitialized = true;

    if (mCoverflowMode) {

        mScrollDirection = Qt::Horizontal;

        mNextScrollDirection = mScrollDirection;

    }

}

HgMediaWallRenderer::~HgMediaWallRenderer()

{

    delete mRenderer;

    delete mStateMachine;

}

void HgMediaWallRenderer::setCameraDistance(qreal distance)

{

    mCameraDistance = distance;

}

void HgMediaWallRenderer::setCameraRotationY(qreal angle)

{

    mCameraRotationY = angle;

}

void HgMediaWallRenderer::setCameraRotationZ(qreal angle)

{

    mCameraRotationZ = angle;

}

qreal HgMediaWallRenderer::getCameraDistance() const

{

    return mCameraDistance;

}

qreal HgMediaWallRenderer::getCameraRotationY() const

{

    return mCameraRotationY;

}

qreal HgMediaWallRenderer::getCameraRotationZ() const

{

    return mCameraRotationZ;

}

void HgMediaWallRenderer::draw(

    const QPointF& startPosition,

    const QPointF& position, 

    const QPointF& targetPosition, 

    qreal springVelocity,

    QPainter* painter, 

    const QTransform& sceneTransform,

    const QRectF& rect)

{

    // save new rect

    mRect = rect;

    // if still not initialized we cant draw anything

    if (!mRendererInitialized)

        return;

    if (mScrollDirection != mNextScrollDirection)

    {

        startScrollDirectionChangeAnimation(startPosition, position, 

            targetPosition, springVelocity, painter, sceneTransform,

            rect);

    }

    else if (mRowCount != mNextRowCount)

    {

        startRowCountChangeAnimation(startPosition, position, 

            targetPosition, springVelocity, painter, sceneTransform,

            rect);

    }

    else

    {

        if (!mStateAnimationOnGoing)

        {

            setupRows(startPosition, position, targetPosition, springVelocity, painter);

        }

        else

        {

            setupStateAnimation(painter);

        }    

    }

    updateCameraMatrices();

    drawQuads(painter, sceneTransform);

}

void HgMediaWallRenderer::setupRows(const QPointF& startPosition,

    const QPointF& position, 

    const QPointF& targetPosition, 

    qreal springVelocity,

    QPainter* painter)

{

    // draw the state for it 

    resetQuads();

    updateSpacingAndImageSize();

    if (mCoverflowMode)

    {

        //setupRow(startPosition, position, targetPosition, springVelocity, painter, 0);

        setupCoverflow(startPosition, position, targetPosition, springVelocity, painter);

    }

    else

    {

        if (mScrollDirection == Qt::Vertical)

        {

            setupGridPortrait(startPosition, position, targetPosition, 

              springVelocity, painter);            

        }

        else

        {

            setupGridLandscape(startPosition, position, targetPosition, 

                springVelocity, painter);

        }

    }        

}

qreal HgMediaWallRenderer::animationAlpha() const

{

    return mAnimationAlpha;

}

void HgMediaWallRenderer::setAnimationAlpha(qreal alpha)

{

    mAnimationAlpha = alpha;

    emit renderingNeeded();

}

qreal HgMediaWallRenderer::stateAnimationAlpha() const

{

    return mStateAnimationAlpha;

}

void HgMediaWallRenderer::setStateAnimationAlpha(qreal alpha)

{

    mStateAnimationAlpha = alpha;

    if (alpha == 1 && mStateAnimationOnGoing)

    {

        mStateAnimationOnGoing = false;

    }

    emit renderingNeeded();

}

void HgMediaWallRenderer::createStateMachine()

{

    mStateMachine = new QStateMachine(this);

    mStateMachine->setAnimated(true);

    QState* root = new QState(QState::ParallelStates);

    QState* p2 = new QState(root);

    // create two states to animate between

    {

        QState* s1 = new QState(p2);

        QState* s2 = new QState(p2);

        s1->assignProperty(this, "stateAnimationAlpha", qreal(0));

        s2->assignProperty(this, "stateAnimationAlpha", qreal(0));

        QPropertyAnimation* anim = new QPropertyAnimation(this, "stateAnimationAlpha");

        anim->setStartValue(qreal(0));

        anim->setEndValue(qreal(1));

        anim->setDuration(mStateAnimationDuration);

        s1->addTransition(this, SIGNAL(toggleState()), s2)->addAnimation(anim);

        s2->addTransition(this, SIGNAL(toggleState()), s1)->addAnimation(anim);        

        p2->setInitialState(s1);        

    }

    root->setInitialState(p2);

    mStateMachine->addState(root);    

    mStateMachine->setInitialState(root);

    mStateMachine->start();

}

void HgMediaWallRenderer::setScrollDirection(Qt::Orientation scrollDirection, bool animate)

{

    // coverflow is always horizontal

    if (mCoverflowMode)

    {

        mScrollDirection = Qt::Horizontal;

        mNextScrollDirection = mScrollDirection;

        return;

    }

    if (mScrollDirection != scrollDirection)

    {

        mStateMachine->setAnimated(animate);

        mNextScrollDirection = scrollDirection;

        if (!animate) {

            mScrollDirection = scrollDirection;

        }

        else

        {

            //emit renderingNeeded();            

        }

    } else if (!animate) {

        // reset next scrolldirection just to be sure. In some cases

        // when orientation changes couple of times and container visibility changes

        // we might otherwise end up in wrong state.

        mNextScrollDirection = scrollDirection;

    }

}

Qt::Orientation HgMediaWallRenderer::getScrollDirection() const

{

    return mScrollDirection;

}

void HgMediaWallRenderer::drawQuads(QPainter* painter, 

    const QTransform& sceneTransform)

{

    mRenderer->drawQuads(painter, mRect, mViewMatrix, mProjMatrix, mOrientation, 

        sceneTransform);    

}

void HgMediaWallRenderer::enableCoverflowMode(bool enabled)

{

    mCoverflowMode = enabled;

}

bool HgMediaWallRenderer::coverflowModeEnabled() const

{

    return mCoverflowMode;

}

void HgMediaWallRenderer::setRowCount(int rowCount, const QSizeF& newImageSize, bool animate)

{

    if (rowCount != mRowCount)

    {

        mStateMachine->setAnimated(animate);

        mNextRowCount = rowCount;

        mNextImageSize = newImageSize;

        mColumnCount = rowCount;

        if (!animate)

        {

            mRowCount = rowCount;

        }

        else

        {

            emit renderingNeeded();            

        }

    }

}

int HgMediaWallRenderer::getRowCount() const