/****************************************************************************

**

** 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 QtDeclarative module of the Qt Toolkit.

**

** $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 "private/qdeclarativepixmapcache_p.h"

#include "qdeclarativenetworkaccessmanagerfactory.h"

#include "qdeclarativeimageprovider.h"

#include <qdeclarativeengine.h>

#include <private/qdeclarativeglobal_p.h>

#include <private/qdeclarativeengine_p.h>

#include <QCoreApplication>

#include <QImageReader>

#include <QHash>

#include <QNetworkReply>

#include <QPixmapCache>

#include <QFile>

#include <QThread>

#include <QMutex>

#include <QBuffer>

#include <QWaitCondition>

#include <QtCore/qdebug.h>

#include <private/qobject_p.h>

#include <QSslError>

// Maximum number of simultaneous image requests to send.

static const int maxImageRequestCount = 8;

QT_BEGIN_NAMESPACE

class QDeclarativeImageReaderEvent : public QEvent

{

public:

    enum ReadError { NoError, Loading, Decoding };

    QDeclarativeImageReaderEvent(QDeclarativeImageReaderEvent::ReadError err, const QString &errStr, const QImage &img)

        : QEvent(QEvent::User), error(err), errorString(errStr), image(img) {}

    ReadError error;

    QString errorString;

    QImage image;

};

class QDeclarativeImageRequestHandler;

class QDeclarativeImageReader : public QThread

{

    Q_OBJECT

public:

    QDeclarativeImageReader(QDeclarativeEngine *eng);

    ~QDeclarativeImageReader();

    QDeclarativePixmapReply *getImage(const QUrl &url, int req_width, int req_height);

    void cancel(QDeclarativePixmapReply *rep);

    static QDeclarativeImageReader *instance(QDeclarativeEngine *engine);

protected:

    void run();

private:

    QList<QDeclarativePixmapReply*> jobs;

    QList<QDeclarativePixmapReply*> cancelled;

    QDeclarativeEngine *engine;

    QDeclarativeImageRequestHandler *handler;

    QObject *eventLoopQuitHack;

    QMutex mutex;

    static QHash<QDeclarativeEngine *,QDeclarativeImageReader*> readers;

    static QMutex readerMutex;

    friend class QDeclarativeImageRequestHandler;

};

QHash<QDeclarativeEngine *,QDeclarativeImageReader*> QDeclarativeImageReader::readers;

QMutex QDeclarativeImageReader::readerMutex;

class QDeclarativeImageRequestHandler : public QObject

{

    Q_OBJECT

public:

    QDeclarativeImageRequestHandler(QDeclarativeImageReader *read, QDeclarativeEngine *eng)

        : QObject(), accessManager(0), engine(eng), reader(read), redirectCount(0)

    {

        QCoreApplication::postEvent(this, new QEvent(QEvent::User));

    }

    QDeclarativePixmapReply *getImage(const QUrl &url, int req_width, int req_height);

    void cancel(QDeclarativePixmapReply *reply);

protected:

    bool event(QEvent *event);

private slots:

    void networkRequestDone();

private:

    QNetworkAccessManager *networkAccessManager() {

        if (!accessManager)

            accessManager = QDeclarativeEnginePrivate::get(engine)->createNetworkAccessManager(this);

        return accessManager;

    }

    QHash<QNetworkReply*,QDeclarativePixmapReply*> replies;

    QNetworkAccessManager *accessManager;

    QDeclarativeEngine *engine;

    QDeclarativeImageReader *reader;

    int redirectCount;

    static int replyDownloadProgress;

    static int replyFinished;

    static int downloadProgress;

    static int thisNetworkRequestDone;

};

//===========================================================================

static bool readImage(const QUrl& url, QIODevice *dev, QImage *image, QString *errorString, QSize *impsize, int req_width, int req_height)

{

    QImageReader imgio(dev);

    bool force_scale = false;

    if (url.path().endsWith(QLatin1String(".svg"),Qt::CaseInsensitive)) {

        imgio.setFormat("svg"); // QSvgPlugin::capabilities bug QTBUG-9053

        force_scale = true;

    }

    bool scaled = false;

    if (req_width > 0 || req_height > 0) {

        QSize s = imgio.size();

        if (req_width && (force_scale || req_width < s.width())) {

            if (req_height <= 0)

                s.setHeight(s.height()*req_width/s.width());

            s.setWidth(req_width); scaled = true;

        }

        if (req_height && (force_scale || req_height < s.height())) {

            if (req_width <= 0)

                s.setWidth(s.width()*req_height/s.height());

            s.setHeight(req_height); scaled = true;

        }

        if (scaled) { imgio.setScaledSize(s); }

    }

    if (impsize)

        *impsize = imgio.size();

    if (imgio.read(image)) {

        if (impsize && impsize->width() < 0)

            *impsize = image->size();

        return true;

    } else {

        if (errorString)

            *errorString = QDeclarativePixmapCache::tr("Error decoding: %1: %2").arg(url.toString())

                                .arg(imgio.errorString());

        return false;

    }

}

//===========================================================================

int QDeclarativeImageRequestHandler::replyDownloadProgress = -1;

int QDeclarativeImageRequestHandler::replyFinished = -1;

int QDeclarativeImageRequestHandler::downloadProgress = -1;

int QDeclarativeImageRequestHandler::thisNetworkRequestDone = -1;

typedef QHash<QUrl, QSize> QDeclarativePixmapSizeHash;

Q_GLOBAL_STATIC(QDeclarativePixmapSizeHash, qmlOriginalSizes);

bool QDeclarativeImageRequestHandler::event(QEvent *event)

{

    if (event->type() == QEvent::User) {

        if (replyDownloadProgress == -1) {

            replyDownloadProgress = QNetworkReply::staticMetaObject.indexOfSignal("downloadProgress(qint64,qint64)");

            replyFinished = QNetworkReply::staticMetaObject.indexOfSignal("finished()");

            downloadProgress = QDeclarativePixmapReply::staticMetaObject.indexOfSignal("downloadProgress(qint64,qint64)");

            thisNetworkRequestDone = QDeclarativeImageRequestHandler::staticMetaObject.indexOfSlot("networkRequestDone()");

        }

        while (1) {

            reader->mutex.lock();

            if (reader->cancelled.count()) {

                for (int i = 0; i < reader->cancelled.count(); ++i) {

                    QDeclarativePixmapReply *job = reader->cancelled.at(i);

                    // cancel any jobs already started

                    QNetworkReply *reply = replies.key(job, 0);

                    if (reply && reply->isRunning()) {

                        replies.remove(reply);

                        reply->close();

                    }

                    // remove from pending job list

                    for (int j = 0; j < reader->jobs.count(); ++j) {

                        if (reader->jobs.at(j) == job) {

                            reader->jobs.removeAt(j);

                            job->release(true);

                            break;

                        }

                    }

                }

                reader->cancelled.clear();

            }

            if (!reader->jobs.count() || replies.count() > maxImageRequestCount) {

                reader->mutex.unlock();

                break;

            }

            QDeclarativePixmapReply *runningJob = reader->jobs.takeLast();

            QUrl url = runningJob->url();

            reader->mutex.unlock();

            // fetch

            if (url.scheme() == QLatin1String("image")) {

                // Use QmlImageProvider

                QSize read_impsize;

                QImage image = QDeclarativeEnginePrivate::get(engine)->getImageFromProvider(url, &read_impsize, QSize(runningJob->forcedWidth(),runningJob->forcedHeight()));

                qmlOriginalSizes()->insert(url, read_impsize);

                QDeclarativeImageReaderEvent::ReadError errorCode = QDeclarativeImageReaderEvent::NoError;

                QString errorStr;

                if (image.isNull()) {

                    errorCode = QDeclarativeImageReaderEvent::Loading;

                    errorStr = QDeclarativePixmapCache::tr("Failed to get image from provider: %1").arg(url.toString());

                }

                QCoreApplication::postEvent(runningJob, new QDeclarativeImageReaderEvent(errorCode, errorStr, image));

            } else {

                QString lf = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(url);

                if (!lf.isEmpty()) {

                    // Image is local - load/decode immediately

                    QImage image;

                    QDeclarativeImageReaderEvent::ReadError errorCode = QDeclarativeImageReaderEvent::NoError;

                    QString errorStr;

                    QFile f(lf);

                    if (f.open(QIODevice::ReadOnly)) {

                        QSize read_impsize;

                        if (readImage(url, &f, &image, &errorStr, &read_impsize, runningJob->forcedWidth(),runningJob->forcedHeight())) {

                            qmlOriginalSizes()->insert(url, read_impsize);

                        } else {

                            errorCode = QDeclarativeImageReaderEvent::Loading;

                        }

                    } else {

                        errorStr = QDeclarativePixmapCache::tr("Cannot open: %1").arg(url.toString());

                        errorCode = QDeclarativeImageReaderEvent::Loading;

                    }

                    QCoreApplication::postEvent(runningJob, new QDeclarativeImageReaderEvent(errorCode, errorStr, image));

                } else {

                    // Network resource

                    QNetworkRequest req(url);

                    req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true);

                    QNetworkReply *reply = networkAccessManager()->get(req);

                    QMetaObject::connect(reply, replyDownloadProgress, runningJob, downloadProgress);

                    QMetaObject::connect(reply, replyFinished, this, thisNetworkRequestDone);

                    replies.insert(reply, runningJob);

                }

            }

        }

        return true;

    }

    return QObject::event(event);

}

#define IMAGEREQUESTHANDLER_MAX_REDIRECT_RECURSION 16

void QDeclarativeImageRequestHandler::networkRequestDone()

{

    QNetworkReply *reply = static_cast<QNetworkReply *>(sender());

    QDeclarativePixmapReply *job = replies.take(reply);

    redirectCount++;

    if (redirectCount < IMAGEREQUESTHANDLER_MAX_REDIRECT_RECURSION) {

        QVariant redirect = reply->attribute(QNetworkRequest::RedirectionTargetAttribute);

        if (redirect.isValid()) {

            QUrl url = reply->url().resolved(redirect.toUrl());

            QNetworkRequest req(url);

            req.setAttribute(QNetworkRequest::HttpPipeliningAllowedAttribute, true);

            reply->deleteLater();

            reply = networkAccessManager()->get(req);

            QMetaObject::connect(reply, replyDownloadProgress, job, downloadProgress);

            QMetaObject::connect(reply, replyFinished, this, thisNetworkRequestDone);

            replies.insert(reply, job);

            return;

        }

    }

    redirectCount=0;

    if (job) {

        QImage image;

        QDeclarativeImageReaderEvent::ReadError error;

        QString errorString;

        if (reply->error()) {

            error = QDeclarativeImageReaderEvent::Loading;

            errorString = reply->errorString();

        } else {

            QSize read_impsize;

            QByteArray all = reply->readAll();

            QBuffer buff(&all);

            buff.open(QIODevice::ReadOnly);

            if (readImage(reply->url(), &buff, &image, &errorString, &read_impsize, job->forcedWidth(), job->forcedHeight())) {

                qmlOriginalSizes()->insert(reply->url(), read_impsize);

                error = QDeclarativeImageReaderEvent::NoError;

            } else {

                error = QDeclarativeImageReaderEvent::Decoding;

            }

        }

        // send completion event to the QDeclarativePixmapReply

        QCoreApplication::postEvent(job, new QDeclarativeImageReaderEvent(error, errorString, image));

    }

    // kick off event loop again if we have dropped below max request count

    if (replies.count() == maxImageRequestCount)

        QCoreApplication::postEvent(this, new QEvent(QEvent::User));

    reply->deleteLater();

}

//===========================================================================

QDeclarativeImageReader::QDeclarativeImageReader(QDeclarativeEngine *eng)

    : QThread(eng), engine(eng), handler(0)

{

    eventLoopQuitHack = new QObject;

    eventLoopQuitHack->moveToThread(this);

    connect(eventLoopQuitHack, SIGNAL(destroyed(QObject*)), SLOT(quit()), Qt::DirectConnection);

    start(QThread::IdlePriority);

}

QDeclarativeImageReader::~QDeclarativeImageReader()

{

    readerMutex.lock();

    readers.remove(engine);

    readerMutex.unlock();

    eventLoopQuitHack->deleteLater();

    wait();

}

QDeclarativeImageReader *QDeclarativeImageReader::instance(QDeclarativeEngine *engine)

{

    readerMutex.lock();

    QDeclarativeImageReader *reader = readers.value(engine);

    if (!reader) {

        reader = new QDeclarativeImageReader(engine);

        readers.insert(engine, reader);

    }

    readerMutex.unlock();

    return reader;

}

QDeclarativePixmapReply *QDeclarativeImageReader::getImage(const QUrl &url, int req_width, int req_height)

{

    mutex.lock();

    QDeclarativePixmapReply *reply = new QDeclarativePixmapReply(this, url, req_width, req_height);

    reply->addRef();

    reply->setLoading();

    jobs.append(reply);

    if (jobs.count() == 1 && handler)

        QCoreApplication::postEvent(handler, new QEvent(QEvent::User));

    mutex.unlock();

    return reply;

}

void QDeclarativeImageReader::cancel(QDeclarativePixmapReply *reply)

{

    mutex.lock();

    if (reply->isLoading()) {

        // Add to cancel list to be cancelled in reader thread.

        cancelled.append(reply);

        if (cancelled.count() == 1 && handler)

            QCoreApplication::postEvent(handler, new QEvent(QEvent::User));

    }

    mutex.unlock();

}

void QDeclarativeImageReader::run()

{

    readerMutex.lock();

    handler = new QDeclarativeImageRequestHandler(this, engine);

    readerMutex.unlock();

    exec();

    delete handler;

    handler = 0;

}

//===========================================================================

/*!

    \internal

    \class QDeclarativePixmapCache

    \brief Enacapsultes a pixmap for QDeclarativeGraphics items.

    This class is NOT reentrant.

 */

typedef QHash<QUrl, QDeclarativePixmapReply *> QDeclarativePixmapReplyHash;

Q_GLOBAL_STATIC(QDeclarativePixmapReplyHash, qmlActivePixmapReplies);

class QDeclarativePixmapReplyPrivate : public QObjectPrivate

{

    Q_DECLARE_PUBLIC(QDeclarativePixmapReply)

public:

    QDeclarativePixmapReplyPrivate(QDeclarativeImageReader *r, const QUrl &u, int req_width, int req_height)

        : QObjectPrivate(), refCount(1), url(u), status(QDeclarativePixmapReply::Loading), loading(false), reader(r),

            forced_width(req_width), forced_height(req_height)

    {

    }

    int refCount;

    QUrl url;

    QPixmap pixmap; // ensure reference to pixmap so QPixmapCache does not discard

    QDeclarativePixmapReply::Status status;

    bool loading;

    QDeclarativeImageReader *reader;

    int forced_width, forced_height;

    QString errorString;

};

QDeclarativePixmapReply::QDeclarativePixmapReply(QDeclarativeImageReader *reader, const QUrl &url, int req_width, int req_height)

  : QObject(*new QDeclarativePixmapReplyPrivate(reader, url, req_width, req_height), 0)

{

}

QDeclarativePixmapReply::~QDeclarativePixmapReply()

{

}

const QUrl &QDeclarativePixmapReply::url() const

{

    Q_D(const QDeclarativePixmapReply);

    return d->url;

}

int QDeclarativePixmapReply::forcedWidth() const

{

    Q_D(const QDeclarativePixmapReply);

    return d->forced_width;

}

int QDeclarativePixmapReply::forcedHeight() const

{

    Q_D(const QDeclarativePixmapReply);

    return d->forced_height;

}

QSize QDeclarativePixmapReply::implicitSize() const

{

    Q_D(const QDeclarativePixmapReply);

    QDeclarativePixmapSizeHash::Iterator iter = qmlOriginalSizes()->find(d->url);

    if (iter != qmlOriginalSizes()->end())

        return *iter;

    else

        return QSize();

}

bool QDeclarativePixmapReply::event(QEvent *event)

{

    Q_D(QDeclarativePixmapReply);

    if (event->type() == QEvent::User) {

        d->loading = false;

        if (!release(true)) {

            QDeclarativeImageReaderEvent *de = static_cast<QDeclarativeImageReaderEvent*>(event);

            d->status = (de->error == QDeclarativeImageReaderEvent::NoError) ? Ready : Error;

            if (d->status == Ready)

                d->pixmap = QPixmap::fromImage(de->image);

            else

                d->errorString =  de->errorString;

            QByteArray key = d->url.toEncoded(QUrl::FormattingOption(0x100));

            QString strKey = QString::fromLatin1(key.constData(), key.count());

            QPixmapCache::insert(strKey, d->pixmap); // note: may fail (returns false)

            emit finished();

        }

        return true;

    }

    return QObject::event(event);

}

QString QDeclarativePixmapReply::errorString() const

{

    Q_D(const QDeclarativePixmapReply);

    return d->errorString;

}