#include <QMutexLocker>

#include <QWaitCondition>

#define IMAGEREQUEST_MAX_REQUEST_COUNT       8

#define IMAGEREQUEST_MAX_REDIRECT_RECURSION 16

#define CACHE_EXPIRE_TIME 30

#define CACHE_REMOVAL_FRACTION 4

class QDeclarativePixmapReader;

class QDeclarativePixmapData;

class QDeclarativePixmapReply : public QObject

    Q_OBJECT

    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

    QDeclarativePixmapReader(QDeclarativeEngine *eng);

    ~QDeclarativePixmapReader();

    QDeclarativePixmapReply *getImage(QDeclarativePixmapData *);

    static QDeclarativePixmapReader *instance(QDeclarativeEngine *engine);

    friend class QDeclarativePixmapReaderThreadObject;

    void processJobs();

    void processJob(QDeclarativePixmapReply *);

    void networkRequestDone(QNetworkReply *);

    QMutex mutex;

    QDeclarativePixmapReaderThreadObject *threadObject;

    QWaitCondition waitCondition;

    QNetworkAccessManager *networkAccessManager();

    QNetworkAccessManager *accessManager;

    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)

    if (requestSize.width() > 0 || requestSize.height() > 0) {

        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;

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

QDeclarativePixmapReader::QDeclarativePixmapReader(QDeclarativeEngine *eng)

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

QDeclarativePixmapReader::~QDeclarativePixmapReader()

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();

            processJob(runningJob);

            locker.relock();

        }

    }

}

void QDeclarativePixmapReader::processJob(QDeclarativePixmapReply *runningJob)

{

    QUrl url = runningJob->data->url;

    // fetch

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

        // Use QmlImageProvider

        QSize readSize;

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

        QImage image = ep->getImageFromProvider(url, &readSize, runningJob->data->requestSize);

        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)) {

                if (!readImage(url, &f, &image, &errorStr, &readSize, runningJob->data->requestSize))

                    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)

    QDeclarativePixmapReader *reader = readers.value(engine);

        reader = new QDeclarativePixmapReader(engine);

QDeclarativePixmapReply *QDeclarativePixmapReader::getImage(QDeclarativePixmapData *data)