/*
* 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 "hgvgquadrenderer.h"
#include "hgtransformedquad.h"
#include "hgquad.h"
#include "hgvgimage.h"
#include "trace.h"
#include "hgimagefader.h"

#include <VG/openvg.h>
#include <VG/vgu.h>
#include <QVector2D>
#include <QPolygon>
#include <QMatrix4x4>
#include <QPainter>

static void matrixFromTransform(VGfloat* matrix, const QTransform& tm)
{
    matrix[0] = tm.m11();
    matrix[1] = tm.m12();
    matrix[2] = tm.m13();

    matrix[3] = tm.m21();
    matrix[4] = tm.m22();
    matrix[5] = tm.m23();

    matrix[6] = tm.m31();
    matrix[7] = tm.m32();
    matrix[8] = tm.m33();
}

class HgVgQuad : public HgTransformedQuad
{
public:
    
    HgVgQuad(HgVgQuadRenderer* renderer) : HgTransformedQuad(-1), mRenderer(renderer)
    {
        
    }

    ~HgVgQuad()
    {
        
    }

    void draw(QPainter* painter, const QRectF& rect)    
    {
        Q_UNUSED(painter)
        Q_UNUSED(rect)
        
        if (!mQuad->visible())
            return;
                
        HgVgImage* image = (HgVgImage*)mQuad->image();
                
        if (image == NULL  || image->alpha() == 0)
        {
            if (mRenderer->defaultImage()) {
                drawImage(mRenderer->defaultImage(), 1.0f);
            }
        }
        else
        {
            image->upload(mQuad->mirrorImageEnabled());
            
            if (image->image() == VG_INVALID_HANDLE)
            {
                if (mRenderer->defaultImage()) {
                    drawImage(mRenderer->defaultImage(), 1.0f);
                }
            }
            else
            {

                if ( mQuad->alpha() < 1.0f )
                {
                    if (mRenderer->defaultImage()) {
                        drawImage(mRenderer->defaultImage(), 1.0f - mQuad->alpha());            
                    }
                }
                
                drawImage(image, mQuad->alpha());
            }
        }
        
        
    }

    void drawImage(HgVgImage* image, qreal alpha)
    {
        Q_UNUSED(alpha)
            
        VGImage vgImage = image->image();
        
        vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);

        VGfloat m[9];
        vgGetMatrix(m);
        
        computeWarpMatrix(mMatrix, image->width(), image->height(), mTransformedPoints, QVector2D());

        vgMultMatrix(mMatrix);
        vgDrawImage(vgImage);    
        
        vgLoadMatrix(m);

        if (mQuad->mirrorImageEnabled())
        {
            VGImage mirrorImage = image->mirrorImage();
            if (mirrorImage == VG_INVALID_HANDLE)
                return;
            
            computeWarpMatrix(mMirrorMatrix, image->mirrorImageWidth(), image->mirrorImageHeight(), mMirroredPoints, QVector2D());
            vgMultMatrix(mMirrorMatrix);
                
            vgDrawImage(mirrorImage);    
            vgLoadMatrix(m);    
        }
        
    }
    
private:

    void computeWarpMatrix(VGfloat* matrix, int pxWidth, int pxHeight, const QVector2D* points, 
        const QVector2D& translate)
    {        
        Q_UNUSED(translate)

        vguComputeWarpQuadToQuad(
            points[0].x(), points[0].y(), 
            points[1].x(), points[1].y(),
            points[2].x(), points[2].y(),
            points[3].x(), points[3].y(),
            0, pxHeight,
            pxWidth, pxHeight,
            pxWidth, 0,
            0, 0,
            matrix);
    
    }

    HgVgQuadRenderer* mRenderer;
    VGfloat mMatrix[9];
    VGfloat mMirrorMatrix[9];
};


HgVgQuadRenderer::HgVgQuadRenderer(int maxQuads) : 
    HgTransformedQuadRenderer(maxQuads),
    mDefaultVgImage(NULL)
{
    init(maxQuads);
}

HgVgQuadRenderer::~HgVgQuadRenderer()
{
    delete mDefaultVgImage;
}

void HgVgQuadRenderer::drawQuads(QPainter* painter, const QRectF& rect, 
    const QMatrix4x4& viewMatrix, const QMatrix4x4& projectionMatrix,
    Qt::Orientation orientation, 
    const QTransform& sceneTransform)
{
    // start direct vg
    painter->beginNativePainting();

    // setup default vg states
    vgSeti(VG_COLOR_TRANSFORM, VG_FALSE);
    vgSeti(VG_BLEND_MODE, VG_BLEND_SRC_OVER);
    vgSeti(VG_IMAGE_MODE, VG_DRAW_IMAGE_NORMAL);

    // setup root transform
    vgSeti(VG_MATRIX_MODE, VG_MATRIX_IMAGE_USER_TO_SURFACE);
    VGfloat toVgMatrix[9];
    matrixFromTransform(toVgMatrix, qtToVgTransform(painter, sceneTransform, rect, orientation));
    vgLoadMatrix(toVgMatrix);   

    // transform quads to screen
    transformQuads(viewMatrix, projectionMatrix, QPointF(rect.width()/2, rect.height()/2), 
        QSizeF(rect.width(), rect.height()));

    drawTransformedQuads(painter, rect);

    // end directt vg
    painter->endNativePainting();
    
}

HgImage* HgVgQuadRenderer::createNativeImage()
{    
    return new HgVgImage(this);   
}

HgTransformedQuad* HgVgQuadRenderer::createNativeQuad()
{
    return new HgVgQuad(this);
}

HgVgImage* HgVgQuadRenderer::defaultImage()
{
    if (mDefaultVgImage && mDefaultVgImage->image() == VG_INVALID_HANDLE) {
        mDefaultVgImage->upload(true);
    }

    return mDefaultVgImage;
}

void HgVgQuadRenderer::setDefaultImage(QImage defaultImage)
{
    HgQuadRenderer::setDefaultImage(defaultImage);
    delete mDefaultVgImage;
    mDefaultVgImage = 0;
    mDefaultVgImage = static_cast<HgVgImage*>(createNativeImage());
    mDefaultVgImage->setImage(mDefaultImage);
    mDefaultVgImage->upload(true);    
}

QTransform HgVgQuadRenderer::qtToVgTransform(QPainter* painter, const QTransform& sceneTransform, 
    const QRectF& rect, Qt::Orientation orientation) const
{
    QTransform t;
    if (orientation == Qt::Vertical)
    {
        t.translate(sceneTransform.dx(), painter->viewport().height() - sceneTransform.dy());
        t.scale(1, -1);    
    }
    else
    {
        // TODO: this will need reviewing later :)
        t.translate(rect.bottom(), 0);
        t.scale(-1, 1);
        t.translate(0, rect.right());
        t.rotate(-90, Qt::ZAxis);        
    }

    return t;
}