#include "messages/Image.hpp"

#include "Application.hpp"
#include "common/NetworkRequest.hpp"
#include "debug/AssertInGuiThread.hpp"
#include "debug/Benchmark.hpp"
#include "debug/Log.hpp"
#include "singletons/Emotes.hpp"
#include "singletons/WindowManager.hpp"
#include "util/DebugCount.hpp"
#include "util/PostToThread.hpp"

#include <QBuffer>
#include <QImageReader>
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QNetworkRequest>
#include <QTimer>
#include <functional>
#include <thread>

namespace chatterino {
namespace {
// Frames
Frames::Frames()
{
    DebugCount::increase("images");
}

Frames::Frames(const QVector<Frame<QPixmap>> &frames)
    : items_(frames)
{
    assertInGuiThread();
    DebugCount::increase("images");

    if (this->animated()) {
        DebugCount::increase("animated images");

        this->gifTimerConnection_ = getApp()->emotes->gifTimer.signal.connect(
            [this] { this->advance(); });
    }
}

Frames::~Frames()
{
    assertInGuiThread();
    DebugCount::decrease("images");

    if (this->animated()) {
        DebugCount::decrease("animated images");
    }

    this->gifTimerConnection_.disconnect();
}

void Frames::advance()
{
    this->durationOffset_ += GIF_FRAME_LENGTH;

    while (true) {
        this->index_ %= this->items_.size();

        if (this->index_ >= this->items_.size()) {
            this->index_ = this->index_;
        }

        if (this->durationOffset_ > this->items_[this->index_].duration) {
            this->durationOffset_ -= this->items_[this->index_].duration;
            this->index_ = (this->index_ + 1) % this->items_.size();
        } else {
            break;
        }
    }
}

bool Frames::animated() const
{
    return this->items_.size() > 1;
}

boost::optional<QPixmap> Frames::current() const
{
    if (this->items_.size() == 0) return boost::none;
    return this->items_[this->index_].image;
}

boost::optional<QPixmap> Frames::first() const
{
    if (this->items_.size() == 0) return boost::none;
    return this->items_.front().image;
}

// functions
QVector<Frame<QImage>> readFrames(QImageReader &reader, const Url &url)
{
    QVector<Frame<QImage>> frames;

    if (reader.imageCount() == 0) {
        log("Error while reading image {}: '{}'", url.string,
            reader.errorString());
        return frames;
    }

    QImage image;
    for (int index = 0; index < reader.imageCount(); ++index) {
        if (reader.read(&image)) {
            QPixmap::fromImage(image);

            int duration = std::max(20, reader.nextImageDelay());
            frames.push_back(Frame<QImage>{image, duration});
        }
    }

    if (frames.size() == 0) {
        log("Error while reading image {}: '{}'", url.string,
            reader.errorString());
    }

    return frames;
}

// parsed
template <typename Assign>
void assignDelayed(
    std::queue<std::pair<Assign, QVector<Frame<QPixmap>>>> &queued,
    std::mutex &mutex, std::atomic_bool &loadedEventQueued)
{
    std::lock_guard<std::mutex> lock(mutex);
    int i = 0;

    while (!queued.empty()) {
        queued.front().first(queued.front().second);
        queued.pop();

        if (++i > 50) {
            QTimer::singleShot(
                3, [&] { assignDelayed(queued, mutex, loadedEventQueued); });
            return;
        }
    }

    getApp()->windows->forceLayoutChannelViews();
    loadedEventQueued = false;
}

template <typename Assign>
auto makeConvertCallback(const QVector<Frame<QImage>> &parsed, Assign assign)
{
    return [parsed, assign] {
        // convert to pixmap
        auto frames = QVector<Frame<QPixmap>>();
        std::transform(parsed.begin(), parsed.end(), std::back_inserter(frames),
                       [](auto &frame) {
                           return Frame<QPixmap>{
                               QPixmap::fromImage(frame.image), frame.duration};
                       });

        // put into stack
        static std::queue<std::pair<Assign, QVector<Frame<QPixmap>>>> queued;
        static std::mutex mutex;

        std::lock_guard<std::mutex> lock(mutex);
        queued.emplace(assign, frames);

        static std::atomic_bool loadedEventQueued{false};

        if (!loadedEventQueued) {
            loadedEventQueued = true;

            QTimer::singleShot(
                100, [=] { assignDelayed(queued, mutex, loadedEventQueued); });
        }
    };
}
}  // namespace

// IMAGE2
ImagePtr Image::fromUrl(const Url &url, qreal scale)
{
    static std::unordered_map<Url, std::weak_ptr<Image>> cache;
    static std::mutex mutex;

    std::lock_guard<std::mutex> lock(mutex);

    auto shared = cache[url].lock();

    if (!shared) {
        cache[url] = shared = ImagePtr(new Image(url, scale));
    } else {
        // Warn("same image loaded multiple times: {}", url.string);
    }

    return shared;
}

ImagePtr Image::fromPixmap(const QPixmap &pixmap, qreal scale)
{
    return ImagePtr(new Image(pixmap, scale));
}

ImagePtr Image::getEmpty()
{
    static auto empty = ImagePtr(new Image);
    return empty;
}

Image::Image()
    : empty_(true)
{
}

Image::Image(const Url &url, qreal scale)
    : url_(url)
    , scale_(scale)
    , shouldLoad_(true)
    , frames_(std::make_unique<Frames>())
{
}

Image::Image(const QPixmap &pixmap, qreal scale)
    : scale_(scale)
    , frames_(std::make_unique<Frames>(
          QVector<Frame<QPixmap>>{Frame<QPixmap>{pixmap, 1}}))
{
}

const Url &Image::url() const
{
    return this->url_;
}

boost::optional<QPixmap> Image::pixmap() const
{
    assertInGuiThread();

    if (this->shouldLoad_) {
        const_cast<Image *>(this)->shouldLoad_ = false;
        const_cast<Image *>(this)->load();
    }

    return this->frames_->current();
}

qreal Image::scale() const
{
    return this->scale_;
}

bool Image::isEmpty() const
{
    return this->empty_;
}

bool Image::animated() const
{
    assertInGuiThread();

    return this->frames_->animated();
}

int Image::width() const
{
    assertInGuiThread();

    if (auto pixmap = this->frames_->first())
        return pixmap->width() * this->scale_;
    else
        return 16;
}

int Image::height() const
{
    assertInGuiThread();

    if (auto pixmap = this->frames_->first())
        return pixmap->height() * this->scale_;
    else
        return 16;
}

void Image::load()
{
    NetworkRequest req(this->url().string);
    req.setExecuteConcurrently(true);
    req.setCaller(&this->object_);
    req.setUseQuickLoadCache(true);
    req.onSuccess([that = this, weak = weakOf(this)](auto result) -> Outcome {
        auto shared = weak.lock();
        if (!shared) return Failure;

        auto data = result.getData();

        // const cast since we are only reading from it
        QBuffer buffer(const_cast<QByteArray *>(&data));
        buffer.open(QIODevice::ReadOnly);
        QImageReader reader(&buffer);
        auto parsed = readFrames(reader, that->url());

        postToThread(makeConvertCallback(parsed, [weak](auto frames) {
            if (auto shared = weak.lock())
                shared->frames_ = std::make_unique<Frames>(frames);
        }));

        return Success;
    });

    req.execute();
}

bool Image::operator==(const Image &other) const
{
    if (this->isEmpty() && other.isEmpty()) return true;
    if (!this->url_.string.isEmpty() && this->url_ == other.url_) return true;
    if (this->frames_->first() == other.frames_->first()) return true;

    return false;
}

bool Image::operator!=(const Image &other) const
{
    return !this->operator==(other);
}

}  // namespace chatterino