/*
* 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 "hgqtquadrenderer.h"
#include "hgquad.h"
#include "hgtransformedquad.h"
#include "trace.h"
#include "hgimage.h"

#include <QVector2D>
#include <QPolygon>
#include <QMatrix4x4>
#include <QPainter>
#include <QPixmapCache>


class HgQtImage : public HgImage
{
public:    
    HgQtImage(HgQtQuadRenderer* renderer)
    {
    Q_UNUSED(renderer)
    }

    ~HgQtImage()
    {
    }

    int width() const {
        return mPixmap.width();
    }

    int height() const {
        return mPixmap.height();
    }

    int mirrorPixmapWidth() const {
        return mMirrorPixmap.width();
    }

    int mirrorPixmapHeight() const {
        return mMirrorPixmap.height();
    }
    
    void setPixmap(const QPixmap& pixmap, bool createMirror) {
        mPixmap = pixmap;        
        if (createMirror) {
            createMirrorPixmap(mPixmap);
        } else {
            mMirrorPixmap = QPixmap();
        }
    }
    
    void releaseImages() {
        mPixmap = QPixmap();
        mMirrorPixmap = QPixmap();
    }
            
    QPixmap pixmap() const {
        return mPixmap;
    }
    
    QPixmap mirrorPixmap() {
        return mMirrorPixmap;
    }

    void setMirrorPixmap(const QPixmap& mirrorPixmap) {
        mMirrorPixmap = mirrorPixmap;
    }
    
    void createMirrorPixmap(const QPixmap& source) {
        if (!source.isNull()) {
            mMirrorPixmap = source.copy(QRect(0,source.height()*ReflectionHeight,source.width(),source.height()));
            QPainter painter(&mMirrorPixmap);
            painter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
            QLinearGradient gradient(0.5,0.0,0.5,1);
            gradient.setCoordinateMode(QGradient::ObjectBoundingMode);
            gradient.setColorAt(1, QColor::fromRgb(0,0,0,128));
            gradient.setColorAt(0, QColor::fromRgb(0,0,0,0));
            QBrush brush(gradient);
            painter.setBrush(brush);
            painter.setPen(Qt::NoPen);
            painter.drawRect(mMirrorPixmap.rect());
        }    
    }
    
    void updateMirror(bool enabled) {
        if (enabled && !mPixmap.isNull() && mMirrorPixmap.isNull()) {
            createMirrorPixmap(mPixmap);
        } else if(!enabled) {
            mMirrorPixmap = QPixmap();
        }
    }
    
    QPixmap mPixmap;
    QPixmap mMirrorPixmap;
};

class HgQtQuad : public HgTransformedQuad
{
public:
    
    HgQtQuad(HgQtQuadRenderer* renderer) : HgTransformedQuad(-1), mRenderer(renderer)
    {
        
    }

    ~HgQtQuad()
    {
        
    }

    void draw(QPainter* painter, const QRectF& rect, const QTransform& transform)    
    {
        if (!quad()->visible())
            return;
                
        HgQtImage* image = (HgQtImage*)quad()->image();        
        if (image == NULL)
            image = mRenderer->defaultImage();
        
        if (image == NULL)
            return;
        
        if (image->pixmap().isNull())
            image = mRenderer->defaultImage();
        
        drawImage(painter, image, rect, transform);                      
    }

    
private:

    void computeWarpMatrix(QTransform& tm, int pxWidth, int pxHeight, const QVector2D* points)
    {
        QPolygonF poly;

        poly << points[0].toPointF();
        poly << points[1].toPointF();
        poly << points[2].toPointF();
        poly << points[3].toPointF();

        QPolygonF img;

        img.append(QPointF(0,pxHeight));
        img.append(QPointF(pxWidth,pxHeight));
        img.append(QPointF(pxWidth,0));
        img.append(QPointF(0,0));

        QTransform::quadToQuad(img, poly, tm);
    }
    
    void drawImage(QPainter* painter, HgQtImage* image, const QRectF& rect, const QTransform& transform)
    {
        QPixmap pixmap = image->pixmap();
        
        if (pixmap.isNull())            
            return;
        
                
        const QVector2D* points = mTransformedPoints;
        if (mRenderer->isReflection() && quad()->mirrorImageEnabled()) {
            points = mMirroredPoints;
            pixmap = image->mirrorPixmap();            
        }
        
        QPolygonF poly;
        poly << points[0].toPointF();
        poly << points[1].toPointF();
        poly << points[2].toPointF();
        poly << points[3].toPointF();        
        QRectF bounds = poly.boundingRect();
        if (!(bounds.intersects(rect) || rect.contains(bounds))) {
            return;
        }
        
        computeWarpMatrix(mTransform, pixmap.width(), pixmap.height(), points);
        
        painter->setTransform(mTransform * transform);    

        painter->drawPixmap(QPointF(0,0), pixmap);
    }

    HgQtQuadRenderer* mRenderer;
    QTransform mTransform;
    QTransform mMirrorTransform;
};


HgQtQuadRenderer::HgQtQuadRenderer(int maxQuads) : 
    HgTransformedQuadRenderer(maxQuads),
    mDefaultQtImage(NULL)
{
    // initialize base class to the end.
    init(maxQuads);
    QImage image(QSize(250,250), QImage::QImage::Format_ARGB32_Premultiplied);
    image.fill(0xFFFFFFFF);
    setDefaultImage(QPixmap::fromImage(image));
    
    QPixmapCache::setCacheLimit(2048);
}

HgQtQuadRenderer::~HgQtQuadRenderer()
{
    delete mDefaultQtImage;
}

void HgQtQuadRenderer::drawQuads(QPainter* painter, const QRectF& rect, 
    const QMatrix4x4& viewMatrix, const QMatrix4x4& projectionMatrix,
    Qt::Orientation orientation, 
    const QTransform& sceneTransform)
{
    Q_UNUSED(orientation)
    Q_UNUSED(sceneTransform)

    transformQuads(viewMatrix, projectionMatrix, 
        QPointF(rect.width()/2, rect.height()/2), QSizeF(rect.width(), rect.height()));
    
    // save old transform
    QTransform temp = painter->transform();

    if (mReflectionsEnabled) 
    {
        mIsReflection = true;

        drawTransformedQuads(painter, rect, temp);    

        painter->setTransform(temp);        
        drawFloor(painter, rect);
    }
    
    mIsReflection = false;
    
    drawTransformedQuads(painter, rect, temp);
        
    painter->setTransform(temp);
    
}

HgImage* HgQtQuadRenderer::createNativeImage()
{    
    return new HgQtImage(this);   
}

HgQtImage* HgQtQuadRenderer::defaultImage()
{
    return mDefaultQtImage;
}

void HgQtQuadRenderer::setDefaultImage(QPixmap defaultImage)
{
    HgQuadRenderer::setDefaultImage(defaultImage);
    
    delete mDefaultQtImage;
    mDefaultQtImage = 0;
    
    mDefaultQtImage = static_cast<HgQtImage*>(createNativeImage());
    mDefaultQtImage->setPixmap(mDefaultImage, true);
}

HgTransformedQuad* HgQtQuadRenderer::createNativeQuad()
{
    return new HgQtQuad(this);
}

bool HgQtQuadRenderer::isReflection() const
{
    return mIsReflection;
}

void HgQtQuadRenderer::drawFloor(QPainter* painter, const QRectF& rect)
{
    Q_UNUSED(painter);
    Q_UNUSED(rect);
}