/****************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt scene graph research project.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qsgtexturemanager.h"

#include <QImage>

#include <qgl.h>
#include <qhash.h>
#include <qqueue.h>
#include <qdatetime.h>

QSGTexture::QSGTexture()
    : m_status(Null)
    , m_texture_id(0)
    , m_ref_count(0)
    , m_has_alpha(false)
    , m_owns_texture(true)
    , m_has_mipmaps(false)
{
}



QSGTexture::~QSGTexture()
{
    if (m_owns_texture)
        glDeleteTextures(1, (GLuint *) &m_texture_id);
}



void QSGTexture::setStatus(Status s)
{
    m_status = s;
    Q_ASSERT(s != Ready || (m_texture_id > 0 && !m_texture_size.isEmpty()));
    emit statusChanged(s);
}


struct QSGTextureCacheKey {
    quint64 cacheKey;

    bool operator==(const QSGTextureCacheKey &other) const {
        return other.cacheKey == cacheKey;
    }
};

struct QSGTextureAsyncUpload {
    QImage image;
    int progress;
    QSGTexture *texture;
};


uint qHash(const QSGTextureCacheKey &key)
{
    return (key.cacheKey >> 32) ^ uint(key.cacheKey);
}

class QSGTextureManagerPrivate
{
public:
    QSGTextureManagerPrivate()
        : context(0)
        , maxUploadTime(5)
        , uploadChunkSize(64)
        , uploadTimer(0)
    {
    }

    QSGContext *context;
    QHash<QSGTextureCacheKey, QSGTexture *> cache;

    QQueue<QSGTextureAsyncUpload> asyncUploads;
    int maxUploadTime;
    int uploadChunkSize;

    int uploadTimer;
    QTime lastUpload;
};



QSGTextureManager::QSGTextureManager()
    : d(new QSGTextureManagerPrivate)
{
}


void QSGTextureManager::setContext(QSGContext *context)
{
    Q_ASSERT(!d->context);

    d->context = context;
    connect(d->context, SIGNAL(aboutToRenderNextFrame()), this, SLOT(processAsyncTextures()));
}

QSGContext *QSGTextureManager::context() const
{
    return d->context;
}


void QSGTextureManager::textureDestroyed(QObject *destroyed)
{
    for (int i=0; i<d->asyncUploads.size(); ++i) {
        if (destroyed == d->asyncUploads[i].texture) {
            d->asyncUploads.removeAt(i);
            break;
        }
    }
}


void QSGTextureManager::swizzleBGRAToRGBA(QImage *image)
{
    const int width = image->width();
    const int height = image->height();
    for (int i = 0; i < height; ++i) {
        uint *p = (uint *) image->scanLine(i);
        for (int x = 0; x < width; ++x)
            p[x] = ((p[x] << 16) & 0xff0000) | ((p[x] >> 16) & 0xff) | (p[x] & 0xff00ff00);
    }
}



QSGTextureRef QSGTextureManager::upload(const QImage &image)
{
    QSGTextureCacheKey key = { image.cacheKey() };
    QSGTexture *texture = d->cache.value(key);
    if (texture)
        return QSGTextureRef(texture);

    GLuint id;
    glGenTextures(1, &id);
    glBindTexture(GL_TEXTURE_2D, id);

#ifdef QT_OPENGL_ES
    QImage i = image;
    swizzleBGRAToRGBA(&i);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, i.width(), i.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, i.constBits());
#else
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, image.width(), image.height(), 0, GL_BGRA, GL_UNSIGNED_BYTE, image.constBits());
#endif

    texture = new QSGTexture;
    texture->setTextureId(id);
    texture->setTextureSize(image.size());
    texture->setAlphaChannel(image.hasAlphaChannel());
    texture->setStatus(QSGTexture::Ready);

    connect(texture, SIGNAL(destroyed(QObject*)), this, SLOT(textureDestroyed(QObject*)));

    d->cache.insert(key, texture);

    QSGTextureRef ref(texture);
    return ref;
}


QSGTextureRef QSGTextureManager::requestUpload(const QImage &image,
                                               const QObject *listener,
                                               const char *slot)
{
    QSGTexture *t = new QSGTexture();
    connect(t, SIGNAL(statusChanged(int)), listener, slot);

    QSGTextureAsyncUpload work;
    work.image = image;
    work.progress = 0;
    work.texture = t;

    d->asyncUploads << work;

    if (d->uploadTimer == 0) {
        d->uploadTimer = startTimer(30);
    }

    return QSGTextureRef(t);
}


void QSGTextureManager::timerEvent(QTimerEvent *)
{
    // ### gunnar:
    // In the future, I forsee us starting / stopping this timer based
    // on wether the vsync animation driver is running or not.
    // Then we can also skip the "time since last upload" logic which
    // is currently kinda messy and unpredictable.
    if (d->lastUpload.elapsed() > 50) {
        // Its been a while since the last frame tick, so we are pausing...
        // Upload a "big" chunk...
        int old = d->maxUploadTime;
        d->maxUploadTime = 50;
        processAsyncTextures();
        d->maxUploadTime = old;
    }
}

void QSGTextureManager::processAsyncTextures()
{
    QTime time;
    time.start();

    d->lastUpload.restart();

    while (!d->asyncUploads.isEmpty()) {

        QSGTextureAsyncUpload &upload = d->asyncUploads.first();

        int w = upload.image.width();
        int h = upload.image.height();

        int hChunkCount = (w + d->uploadChunkSize - 1) / d->uploadChunkSize;
        int vChunkCount = (h + d->uploadChunkSize - 1) / d->uploadChunkSize;
        int chunkCount = hChunkCount * vChunkCount;
        QSGTexture *t = upload.texture;

//        printf("\nASYNC: texture: %p, id=%d, size=(%dx%d), progress: %d / %d (%dx%d)\n",
//               t,
//               t->textureId(),
//               w, h,
//               upload.progress, chunkCount, hChunkCount, vChunkCount);

        // Create or bind the texture...
        if (upload.texture->textureId() == 0) {
            GLuint id;
            glGenTextures(1, &id);
            glBindTexture(GL_TEXTURE_2D, id);
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, w, h, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
            t->setTextureId(id);
            t->setTextureSize(QSize(w, h));
            t->setAlphaChannel(upload.image.hasAlphaChannel());
            t->setStatus(QSGTexture::Loading);
//            printf("ASYNC: created texture %p with id=%d\n", t, id);
        } else {
            glBindTexture(GL_TEXTURE_2D, t->textureId());
        }

        if (time.elapsed() > d->maxUploadTime)
            return;

        int steps = 0;

        while (upload.progress < chunkCount && time.elapsed() < d->maxUploadTime) {
            int x = (upload.progress % hChunkCount) * d->uploadChunkSize;
            int y = (upload.progress / hChunkCount) * d->uploadChunkSize;

            QRect area = QRect(x, y, d->uploadChunkSize, d->uploadChunkSize) & upload.image.rect();

            QImage subImage = upload.image.copy(area);
//            printf("ASYNC: - doing another batch: %d (x=%d, y=%d, w=%d, h=%d\n",
//                   upload.progress,
//                   x, y, subImage.width(), subImage.height());

            swizzleBGRAToRGBA(&subImage);
            glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, subImage.width(), subImage.height(), GL_RGBA, GL_UNSIGNED_BYTE, subImage.constBits());

            ++upload.progress;
        }

        if (upload.progress == chunkCount) {
            t->setStatus(QSGTexture::Ready);
            disconnect(t, SIGNAL(destroyed(QObject*)), this, SLOT(textureDestroyed(QObject*)));
            d->asyncUploads.dequeue();
            if (d->asyncUploads.size() == 0) {
                killTimer(d->uploadTimer);
                d->uploadTimer = 0;
            }
        }
    }

    glBindTexture(GL_TEXTURE_2D, 0);
}