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

**

** 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 <QMutexLocker>

#include <QWaitCondition>

#include <QBuffer>

#include <QWaitCondition>

#include <QtCore/qdebug.h>

#include <private/qobject_p.h>

#include <QSslError>

#define IMAGEREQUEST_MAX_REQUEST_COUNT       8

#define IMAGEREQUEST_MAX_REDIRECT_RECURSION 16

#define CACHE_EXPIRE_TIME 30

#define CACHE_REMOVAL_FRACTION 4

QT_BEGIN_NAMESPACE

class QDeclarativePixmapReader;

class QDeclarativePixmapData;

class QDeclarativePixmapReply : public QObject

{

    Q_OBJECT

public:

    enum ReadError { NoError, Loading, Decoding };

    QDeclarativePixmapReply(QDeclarativePixmapData *);

    ~QDeclarativePixmapReply();

    QDeclarativePixmapData *data;

    QDeclarativePixmapReader *reader;

    bool loading;

    int redirectCount;

    class Event : public QEvent {

    public:

        Event(ReadError, const QString &, const QSize &, const QImage &);

        ReadError error;

        QString errorString;

        QSize implicitSize;

        QImage image;

    };

    void postReply(ReadError, const QString &, const QSize &, const QImage &);

Q_SIGNALS:

    void finished();

    void downloadProgress(qint64, qint64);

protected:

    bool event(QEvent *event);

private:

    Q_DISABLE_COPY(QDeclarativePixmapReply)

public:

    static int finishedIndex;

    static int downloadProgressIndex;

};

class QDeclarativePixmapReaderThreadObject : public QObject {

    Q_OBJECT

public:

    QDeclarativePixmapReaderThreadObject(QDeclarativePixmapReader *);

    void processJobs();

    virtual bool event(QEvent *e);

private slots:

    void networkRequestDone();

private:

    QDeclarativePixmapReader *reader;

};

class QDeclarativePixmapData;

class QDeclarativePixmapReader : public QThread

{

    Q_OBJECT

public:

    QDeclarativePixmapReader(QDeclarativeEngine *eng);

    ~QDeclarativePixmapReader();

    QDeclarativePixmapReply *getImage(QDeclarativePixmapData *);

    void cancel(QDeclarativePixmapReply *rep);

    static QDeclarativePixmapReader *instance(QDeclarativeEngine *engine);

protected:

    void run();

private:

    friend class QDeclarativePixmapReaderThreadObject;

    void processJobs();

    void networkRequestDone(QNetworkReply *);

    QList<QDeclarativePixmapReply*> jobs;

    QList<QDeclarativePixmapReply*> cancelled;

    QDeclarativeEngine *engine;

    QObject *eventLoopQuitHack;

    QMutex mutex;

    QDeclarativePixmapReaderThreadObject *threadObject;

    QWaitCondition waitCondition;

    QNetworkAccessManager *networkAccessManager();

    QNetworkAccessManager *accessManager;

    QHash<QNetworkReply*,QDeclarativePixmapReply*> replies;

    static int replyDownloadProgress;

    static int replyFinished;

    static int downloadProgress;

    static int threadNetworkRequestDone;

    static QHash<QDeclarativeEngine *,QDeclarativePixmapReader*> readers;

    static QMutex readerMutex;

};

class QDeclarativePixmapData

{

public:

    QDeclarativePixmapData(const QUrl &u, const QSize &s, const QString &e)

    : refCount(1), inCache(false), pixmapStatus(QDeclarativePixmap::Error), 

      url(u), errorString(e), requestSize(s), reply(0), prevUnreferenced(0),

      prevUnreferencedPtr(0), nextUnreferenced(0)

    {

    }

    QDeclarativePixmapData(const QUrl &u, const QSize &r)

    : refCount(1), inCache(false), pixmapStatus(QDeclarativePixmap::Loading), 

      url(u), requestSize(r), reply(0), prevUnreferenced(0), prevUnreferencedPtr(0), 

      nextUnreferenced(0)

    {

    }

    QDeclarativePixmapData(const QUrl &u, const QPixmap &p, const QSize &s, const QSize &r)

    : refCount(1), inCache(false), privatePixmap(false), pixmapStatus(QDeclarativePixmap::Ready), 

      url(u), pixmap(p), implicitSize(s), requestSize(r), reply(0), prevUnreferenced(0),

      prevUnreferencedPtr(0), nextUnreferenced(0)

    {

    }

    QDeclarativePixmapData(const QPixmap &p)

    : refCount(1), inCache(false), privatePixmap(true), pixmapStatus(QDeclarativePixmap::Ready),

      pixmap(p), implicitSize(p.size()), requestSize(p.size()), reply(0), prevUnreferenced(0),

      prevUnreferencedPtr(0), nextUnreferenced(0)

    {

    }

    int cost() const;

    void addref();

    void release();

    void addToCache();

    void removeFromCache();

    uint refCount;

    bool inCache:1;

    bool privatePixmap:1;

    QDeclarativePixmap::Status pixmapStatus;

    QUrl url;

    QString errorString;

    QPixmap pixmap;

    QSize implicitSize;

    QSize requestSize;

    QDeclarativePixmapReply *reply;

    QDeclarativePixmapData *prevUnreferenced;

    QDeclarativePixmapData**prevUnreferencedPtr;

    QDeclarativePixmapData *nextUnreferenced;

};

int QDeclarativePixmapReply::finishedIndex = -1;

int QDeclarativePixmapReply::downloadProgressIndex = -1;

// XXX

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

QMutex QDeclarativePixmapReader::readerMutex;

int QDeclarativePixmapReader::replyDownloadProgress = -1;

int QDeclarativePixmapReader::replyFinished = -1;

int QDeclarativePixmapReader::downloadProgress = -1;

int QDeclarativePixmapReader::threadNetworkRequestDone = -1;

void QDeclarativePixmapReply::postReply(ReadError error, const QString &errorString, 

                                        const QSize &implicitSize, const QImage &image)

{

    loading = false;

    QCoreApplication::postEvent(this, new Event(error, errorString, implicitSize, image));

}

QDeclarativePixmapReply::Event::Event(ReadError e, const QString &s, const QSize &iSize, const QImage &i)

: QEvent(QEvent::User), error(e), errorString(s), implicitSize(iSize), image(i)

{

}

QNetworkAccessManager *QDeclarativePixmapReader::networkAccessManager()

{

    if (!accessManager) {

        Q_ASSERT(threadObject);

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

    }

    return accessManager;

}

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

                      const QSize &requestSize)

{

    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 (requestSize.width() > 0 || requestSize.height() > 0) {

        QSize s = imgio.size();

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

            if (requestSize.height() <= 0)

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

            s.setWidth(requestSize.width()); scaled = true;

        }

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

            if (requestSize.width() <= 0)

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

            s.setHeight(requestSize.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 = QDeclarativePixmap::tr("Error decoding: %1: %2").arg(url.toString())

                                .arg(imgio.errorString());

        return false;

    }

}

QDeclarativePixmapReader::QDeclarativePixmapReader(QDeclarativeEngine *eng)

: QThread(eng), engine(eng), threadObject(0), accessManager(0)

{

    eventLoopQuitHack = new QObject;

    eventLoopQuitHack->moveToThread(this);

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

    start(QThread::IdlePriority);

}

QDeclarativePixmapReader::~QDeclarativePixmapReader()

{

    readerMutex.lock();

    readers.remove(engine);

    readerMutex.unlock();

    eventLoopQuitHack->deleteLater();

    wait();

}

void QDeclarativePixmapReader::networkRequestDone(QNetworkReply *reply)

{

    QDeclarativePixmapReply *job = replies.take(reply);

    if (job) {

        job->redirectCount++;

        if (job->redirectCount < IMAGEREQUEST_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, threadObject, threadNetworkRequestDone);

                replies.insert(reply, job);

                return;

            }

        }

        QImage image;

        QDeclarativePixmapReply::ReadError error = QDeclarativePixmapReply::NoError;

        QString errorString;

        QSize readSize;

        if (reply->error()) {

            error = QDeclarativePixmapReply::Loading;

            errorString = reply->errorString();

        } else {

            QByteArray all = reply->readAll();

            QBuffer buff(&all);

            buff.open(QIODevice::ReadOnly);

            if (!readImage(reply->url(), &buff, &image, &errorString, &readSize, job->data->requestSize)) {

                error = QDeclarativePixmapReply::Decoding;

            }

        }

        // send completion event to the QDeclarativePixmapReply

        mutex.lock();

        if (!cancelled.contains(job)) job->postReply(error, errorString, readSize, image);

        mutex.unlock();

    }

    reply->deleteLater();

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

    threadObject->processJobs();

}

QDeclarativePixmapReaderThreadObject::QDeclarativePixmapReaderThreadObject(QDeclarativePixmapReader *i)

: reader(i)

{

}

void QDeclarativePixmapReaderThreadObject::processJobs() 

{ 

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

}

bool QDeclarativePixmapReaderThreadObject::event(QEvent *e) 

{

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

        reader->processJobs(); 

        return true; 

    } else { 

        return QObject::event(e);

    }

}

void QDeclarativePixmapReaderThreadObject::networkRequestDone()

{

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

    reader->networkRequestDone(reply);

}

void QDeclarativePixmapReader::processJobs()

{

    QMutexLocker locker(&mutex);

    while (true) {

        if (cancelled.isEmpty() && (jobs.isEmpty() || replies.count() >= IMAGEREQUEST_MAX_REQUEST_COUNT)) 

            return; // Nothing else to do

        // Clean cancelled jobs

        if (cancelled.count()) {

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

                QDeclarativePixmapReply *job = cancelled.at(i);

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

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

                    // cancel any jobs already started

                    replies.remove(reply);

                    reply->close();

                }

                delete job;

            }

            cancelled.clear();

        }

        if (!jobs.isEmpty() && replies.count() < IMAGEREQUEST_MAX_REQUEST_COUNT) {

            QDeclarativePixmapReply *runningJob = jobs.takeLast();

            runningJob->loading = true;

            locker.unlock();

            locker.relock();

        }

    }

}

{

    // fetch

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

        // Use QmlImageProvider

        QSize readSize;

        QDeclarativeEnginePrivate *ep = QDeclarativeEnginePrivate::get(engine);

        QDeclarativePixmapReply::ReadError errorCode = QDeclarativePixmapReply::NoError;

        QString errorStr;

        if (image.isNull()) {

            errorCode = QDeclarativePixmapReply::Loading;

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

        }

        mutex.lock();

        if (!cancelled.contains(runningJob)) runningJob->postReply(errorCode, errorStr, readSize, image);

        mutex.unlock();

    } else {

        QString lf = QDeclarativeEnginePrivate::urlToLocalFileOrQrc(url);

        if (!lf.isEmpty()) {

            // Image is local - load/decode immediately

            QImage image;

            QDeclarativePixmapReply::ReadError errorCode = QDeclarativePixmapReply::NoError;

            QString errorStr;

            QFile f(lf);

            QSize readSize;

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

                    errorCode = QDeclarativePixmapReply::Loading;

            } else {

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

                errorCode = QDeclarativePixmapReply::Loading;

            }

            mutex.lock();

            if (!cancelled.contains(runningJob)) runningJob->postReply(errorCode, errorStr, readSize, image);

            mutex.unlock();

        } 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, threadObject, threadNetworkRequestDone);

            replies.insert(reply, runningJob);

        }

    }

}

QDeclarativePixmapReader *QDeclarativePixmapReader::instance(QDeclarativeEngine *engine)

{

    readerMutex.lock();