// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause


#undef QT_NO_FOREACH // this file contains unported legacy Q_FOREACH uses

#include <QNetworkReply>
#include <QNetworkRequest>
#include <QNetworkAccessManager>
#include <QNetworkDiskCache>
#include <QtConcurrentMap>
#include "imageanalyzer.h"

/*!
 * This class operates as follows:
 * Parent calls the slot startAnalysis which shoves a list of QStrings into URLQueue and then calls fetchURLs.
 * FetchURLs sends out HTTP GETs for each image it can't get out of the cache.
 * As the responses come in, handleReply tries to create an image out of each and pushes those images into imageQueue.
 * On the last (detected by no outstandingFetches and URLQueue.isEmpty()) call to queueImage (from handleReply)
 * a thread is forked to process all the images. When it finishes, it emits a finished signal that is received
 * by our JavaScript code.
 */

//! [ ImageAnalyzer - Constructor ]
ImageAnalyzer::ImageAnalyzer(QNetworkDiskCache* netcache, QObject* parent)
    : QObject(parent), m_cache(netcache), m_outstandingFetches(0)
{
    /*  ImageAnalyzer only wants to receive http responses
        for requests that it makes, so that's why it has its own
        QNetworkAccessManager. */
    m_network = new QNetworkAccessManager(this);
    m_watcher = new QFutureWatcher<QRgb>(this);
    /*  We want to share a cache with the web browser,
        in case it has some images we want: */
    m_network->setCache(m_cache);

    QObject::connect(m_network, SIGNAL(finished(QNetworkReply*)),
                     this, SLOT(handleReply(QNetworkReply*)));
    QObject::connect(m_watcher, SIGNAL(finished()),
                     this, SLOT(doneProcessing()));
    QObject::connect(m_watcher, SIGNAL(progressValueChanged(int)),
                     this, SLOT(progressStatus(int)));
}
//! [ ImageAnalyzer - Constructor ]
ImageAnalyzer::~ImageAnalyzer()
{
    delete(m_watcher);
}


QRgb ImageAnalyzer::lastResults()
{
    int rTot = 0;
    int bTot = 0;
    int gTot = 0;
    int count = m_watcher->future().results().size();
    foreach (const QRgb & triplet, m_watcher->future().results())
    {
        rTot += qRed(triplet);
        bTot += qBlue(triplet);
        gTot += qGreen(triplet);
    }
    return qRgb(rTot/count, bTot/count, gTot/count);
}

float ImageAnalyzer::lastRed() { return qRed(lastResults())/2.55; }
float ImageAnalyzer::lastGreen() { return qGreen(lastResults())/2.55; }
float ImageAnalyzer::lastBlue() { return qBlue(lastResults())/2.55; }

void ImageAnalyzer::progressStatus(int newstat)
{
    emit updateProgress(newstat, m_watcher->progressMaximum());
}


bool ImageAnalyzer::isBusy()
{
    return m_watcher->isRunning();
}


//! [ ImageAnalyzer - startAnalysis ]
void ImageAnalyzer::startAnalysis(const QStringList & urls)
{
    m_URLQueue = urls;
    fetchURLs();
}
//! [ ImageAnalyzer - startAnalysis ]

/*!
 * Analyzes the entire queue - just starts all our http GETs.
 */
//! [ ImageAnalyzer - fetchURLs ]
void ImageAnalyzer::fetchURLs()
{
    while (!m_URLQueue.isEmpty())
    {
        QString url = m_URLQueue.takeFirst();
        QUrl URL = QUrl(url);
        QIODevice * pData = m_cache->data(URL);
        // Is image already loaded in cache?
        if (pData == 0) {
            // HTTP Get image over network.
            m_outstandingFetches++;
            QNetworkRequest request = QNetworkRequest(URL);
            request.setRawHeader("User-Agent", "Digia - Custom Qt app");
            m_network->get(request);
        } else {
            // Get image from cache
            QImage image;
            image.load(pData, 0);
            if (!image.isNull())
                queueImage(image);
            delete(pData);
        }
    }
}
//! [ ImageAnalyzer - fetchURLs ]
/*
 * Slot to handle the incoming responses from our http GETs
 */
//! [ ImageAnalyzer - handleReply ]
void ImageAnalyzer::handleReply(QNetworkReply * pReply)
{
    m_outstandingFetches--;
    if (pReply->error()) {
        qDebug() << "Error code" << pReply->error();
        qDebug() << "Http code" << pReply->attribute(QNetworkRequest::HttpStatusCodeAttribute);
        return;
    }
    QImage image;
    image.load(pReply, 0);
    pReply->deleteLater();
    if (image.isNull()) {
        qDebug() << "bad image";
        qDebug() << pReply->rawHeaderList();
        foreach (QByteArray element, pReply->rawHeaderList()) {
            qDebug() << element << " = " << pReply->rawHeader(element);
        }
        return;
    }
    queueImage(image);
}
//! [ ImageAnalyzer - handleReply ]

void ImageAnalyzer::doneProcessing()
{
    m_imageQueue = QList<QImage>();
    emit finishedAnalysis();
}
//! [ ImageAnalyzer - queueImage ]
void ImageAnalyzer::queueImage(QImage img)
{
    if (!img.isNull())
        m_imageQueue << img;

    if (m_outstandingFetches == 0 && m_URLQueue.isEmpty()) {
        m_watcher->setFuture(QtConcurrent::mapped(m_imageQueue, averageRGB));
    }
}
//! [ ImageAnalyzer - queueImage ]

//! [ ImageAnalyzer - averageRGB ]
QRgb averageRGB(const QImage &img)
{
    int pixelCount = img.width() * img.height();
    int rAvg, gAvg, bAvg;

    // We waste some time here:
    for (int timeWaster=0; timeWaster < 100; timeWaster++) {
        quint64 rTot = 0;
        quint64 gTot = 0;
        quint64 bTot = 0;
        for (int i=0; i < img.width(); i++) {
            for (int j=0; j < img.height(); j++) {
                QRgb pixel = img.pixel(i,j);
                rTot += qRed(pixel);
                gTot += qGreen(pixel);
                bTot += qBlue(pixel);
            }
        }
        rAvg = (rTot)/(pixelCount);
        gAvg = (gTot)/(pixelCount);
        bAvg = (bTot)/(pixelCount);
    }
    return qRgb(rAvg, gAvg, bAvg);
}
//! [ ImageAnalyzer - averageRGB ]
