/*

* 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 "HgImageFader.h"

#include "hgvgquadrenderer.h"

#include <qvector3d>

#include <qtimer>

#include <qpropertyanimation>

#include <qstate.h>

#include <qabstracttransition>

#include <qstatemachine>

#include <qsignaltransition>

#include <qsequentialanimationgroup>

#include <qparallelanimationgroup>

#include <qvariantanimation>

#include <qpolygon>

#include <qpainter>

#include <qpaintengine>

const Qt::Orientation KDefaultOrientation(Qt::Vertical);

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 HgAnimatedQuad

{

public:

    HgAnimatedQuad(HgQuad* start, HgQuad* end, 

        int duration) : mQuad(start)

    {        

        mPositionAnimation.setDuration(duration);

        mPositionAnimation.setKeyValueAt(0, start->position());

        mPositionAnimation.setKeyValueAt(1.0, end->position());

        mPositionAnimation.setEasingCurve(QEasingCurve::Linear);

        mScaleAnimation.setDuration(duration);

        mScaleAnimation.setKeyValueAt(0, QVector3D(start->scale().x(), start->scale().y(), 0));

        mScaleAnimation.setKeyValueAt(1, QVector3D(end->scale().x(), end->scale().y(), 0));

        mScaleAnimation.setEasingCurve(QEasingCurve::Linear);

    }

    ~HgAnimatedQuad()

    {

    }

    void start()

    {

        mPositionAnimation.start();

        mScaleAnimation.start();

    }

    void update()

    {

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

        QVector3D scale = mScaleAnimation.currentValue().value<QVector3D>();

        mQuad->setScale(QVector2D(scale.x(), scale.y()));

    }

    HgQuad* mQuad;

    MyVectorAnimation mPositionAnimation;

    MyVectorAnimation mScaleAnimation;

};

HgMediaWallRenderer::HgMediaWallRenderer(HgMediaWallDataProvider* provider) :

    mDataProvider(provider),

    mRenderer(NULL),

    mIndicatorRenderer(NULL),

    mRendererInitialized(false),

    mOrientation(KDefaultOrientation),

    mNextOrientation(KDefaultOrientation),

    mStateAnimationAlpha(0),

    mStateAnimationOnGoing(false),

    mAnimationAlpha(0),

    mOpeningAnimationDuration(500),

    mOpenedItem(-1),

    mFlipAngle(qreal(360)),

    mZoomAmount(qreal(0.5)),

    mCoverflowMode(false),

    mRowCount(1),

    mNextRowCount(1),

    mStateAnimationDuration(300),

    mStep(1.1),

    mZfar(-2),

    mSpacing2D(10,10),

    mImageSize2D(100, 60),

    mCameraDistance(0),

    mCameraRotationY(0),

    mCameraRotationZ(0),

    mFrontCoverElevation(0.4),

    mReflectionsEnabled(true),

    mItemCountChanged(false),

    mOpenedItemState(ItemClosed)

{

    createStateMachine();

    mImageFader = new HgImageFader();    

    mRenderer = new HgVgQuadRenderer(256);

    mRendererInitialized = true;

}

HgMediaWallRenderer::~HgMediaWallRenderer()

{

    delete mRenderer;

    delete mImageFader;

    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)

{

    // if still not initialized we cant draw anything

    if (!mRendererInitialized)

        return;

    if (mOrientation != mNextOrientation ||

        mRowCount != mNextRowCount)

    {

        // save old state of the quads         

        recordState(mOldState);

        // goto wanted orientation / rowcount

        mOrientation = mNextOrientation;

        mRowCount = mNextRowCount;

        setImageSize(mNextImageSize);

        // setup quads to new state

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

        // record state for animation

        recordState(mNextState);

        startStateAnimation(painter);

    }

    else

    {

        if (!mStateAnimationOnGoing)

        {

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

        }

        else

        {

            setupStateAnimation(painter);

        }    

    }

    updateCameraMatrices();

    drawQuads(painter);

}

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 (mOrientation == Qt::Vertical)

        {

            setupGridPortrait(startPosition, position, targetPosition, 

              springVelocity, painter);            

        }

        else

        {

            setupGridLandscape(startPosition, position, targetPosition, 

                springVelocity, painter);

        }

    }        

}

void HgMediaWallRenderer::setFlipAnimationAngle(qreal angleInDegrees)

{

    mFlipAngle = angleInDegrees;

}

void HgMediaWallRenderer::setOpeningAnimationType(HgMediaWallRenderer::OpeningAnimationType type)

{

    mOpeningAnimationType = type;

}

void HgMediaWallRenderer::setOpeningAnimationDuration(int msecs)

{

    mOpeningAnimationDuration = msecs;

}

qreal HgMediaWallRenderer::animationAlpha() const

{

    return mAnimationAlpha;

}

void HgMediaWallRenderer::setAnimationAlpha(qreal alpha)

{

    mAnimationAlpha = alpha;

    if (mOpenedItemState == ItemClosing && alpha == 0.0f)

        mOpenedItemState = ItemClosed;

    if (mOpenedItemState == ItemOpening && alpha == 1.0f)

        mOpenedItemState = ItemOpened;

    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* p1 = new QState(root);

    QState* p2 = new QState(root);

    // create idle/opened states

    {            

        QState* idle = new QState(p1);

        QState* opened = new QState(p1);

        idle->assignProperty(this, "animationAlpha", qreal(0));                                

        opened->assignProperty(this, "animationAlpha", qreal(1));

        // add opening animation

        QPropertyAnimation* anim1 = new QPropertyAnimation(this, "animationAlpha");

        anim1->setDuration(mOpeningAnimationDuration);

        idle->addTransition(this, SIGNAL(toggleItem()), opened)->addAnimation(anim1);

        // add closing animation

        QPropertyAnimation* anim2 = new QPropertyAnimation(this, "animationAlpha");

        anim2->setDuration(mOpeningAnimationDuration);

        opened->addTransition(this, SIGNAL(toggleItem()), idle)->addAnimation(anim2);

        QObject::connect(idle, SIGNAL(entered()), this, SLOT(onIdleState()));

        QObject::connect(opened, SIGNAL(entered()), this, SLOT(onOpenedState()));

        p1->setInitialState(idle);

    }

    // 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(p1);

    mStateMachine->addState(root);    

    mStateMachine->setInitialState(root);

    mStateMachine->start();

}

void HgMediaWallRenderer::onIdleState()

{

    emit itemClosed(mOpenedItem);

}

void HgMediaWallRenderer::onOpenedState()

{

    emit itemOpened(mOpenedItem);

}

void HgMediaWallRenderer::setOrientation(Qt::Orientation orientation, bool animate)

{

    if (mOrientation != orientation)

    {

        mStateMachine->setAnimated(animate);

        mNextOrientation = orientation;

        if (!animate)

            mOrientation = orientation;

        else

        {

            emit renderingNeeded();            

        }

    }

}

Qt::Orientation HgMediaWallRenderer::getOrientation() const

{

    return mOrientation;

}

void HgMediaWallRenderer::drawQuads(QPainter* painter)

{

    mRenderer->transformQuads(mViewMatrix, mProjMatrix, mRect);

    mRenderer->drawQuads(mRect, painter);    

}

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

{

    return mRowCount;

}

void HgMediaWallRenderer::recordState(HgMediaWallRenderer::State& state)

{

    // cleanup old quads

    for (int i = 0; i < state.mQuads.size(); i++)

    {

        delete state.mQuads[i];

    }

    state.mQuads.clear();

    // record new quads

    for (int i = 0; i < mRenderer->quadCount(); i++)

    {

        HgQuad* quad = mRenderer->quad(i);

        if (!quad->visible())

            continue;

        state.mQuads.append(quad->copy());

    }    

}

void HgMediaWallRenderer::setupStateAnimation(QPainter* painter)

{

    Q_UNUSED(painter)

    resetQuads();

    // setup quads from animated state

    for (int i = 0; i < mOldState.mQuads.size(); i++)

    {

        mAnimatedQuads[i]->update();

        mRenderer->quad(i)->copyFrom(*mOldState.mQuads[i]);

    }

}

void HgMediaWallRenderer::resetQuads()

{

    for (int i = 0; i < mRenderer->quadCount(); i++)

        mRenderer->quad(i)->setVisible(false);    

}

HgQuad* HgMediaWallRenderer::getQuadAt(const QPointF& position) const

{

    if (!mRendererInitialized)

        return NULL;

    return mRenderer->getQuadAt(position);//mapFromWindow(position));

}

bool HgMediaWallRenderer::isItemOpen() const

{

    return (mOpenedItem != -1 && mAnimationAlpha > 0);

}

void HgMediaWallRenderer::setRect(const QRectF& windowRect)

{

    mRect = windowRect;

}

const QRectF& HgMediaWallRenderer::getRect() const

{

    return mRect;

}

void HgMediaWallRenderer::updateCameraMatrices()

{    

    QMatrix4x4 view;

    view.setToIdentity();

    view.lookAt(QVector3D(0.0, 0.0, 1.0f  + mCameraDistance), 

        QVector3D(0.0f, 0.0f, 0.0f), QVector3D(0.0f, 1.0f, 0.0f));

    QMatrix4x4 rot;

    rot.rotate(mCameraRotationZ, QVector3D(0,0,1));

    rot.rotate(mCameraRotationY, QVector3D(0,1,0));

    view *= rot;

    qreal aspect = mRect.width() / mRect.height();

    QMatrix4x4 proj;

    proj.setToIdentity();

    if (mRect.width() <= mRect.height())

    {

        qreal aspect = mRect.height() / mRect.width();

        proj.frustum(-0.5f, 0.5f, -0.5f*aspect, 0.5f*aspect, 1.0f, 1000.0f);

    }

    else

    {

        qreal aspect = mRect.width() / mRect.height();

        proj.frustum(-0.5f*aspect, 0.5f*aspect, -0.5f, 0.5f, 1.0f, 1000.0f);