#pragma once
#include "json_orders.hpp"
#include <QNetworkAccessManager>
#include <QNetworkReply>
#include <QPointer>
#include <QTimer>

namespace orders {
class OrderDownload final : public QObject {
  Q_OBJECT
  QNetworkAccessManager manager_{this};
  QPointer<QNetworkReply> active_;
  QTimer deadline_{this};
  QByteArray bytes_;
  quint64 generation_{0};
  void discard() {
    ++generation_;
    deadline_.stop();
    if (active_) {
      auto reply = active_;
      active_.clear();
      disconnect(reply, nullptr, this, nullptr);
      reply->abort();
      reply->deleteLater();
    }
    bytes_.clear();
  }
  void fail(const QString &message) {
    discard();
    emit busyChanged(false);
    emit failed(message);
  }
  bool collect(QNetworkReply *reply) {
    bytes_ += reply->read(maximumDocumentBytes + 1 - bytes_.size());
    if (bytes_.size() > maximumDocumentBytes) {
      fail("Response exceeds 256 KiB");
      return false;
    }
    return true;
  }

public:
  explicit OrderDownload(QObject *parent = nullptr) : QObject(parent) {
    deadline_.setSingleShot(true);
    connect(&deadline_, &QTimer::timeout, this,
            [this] { fail("Request timed out"); });
  }
  ~OrderDownload() override { discard(); }
  bool busy() const { return !active_.isNull(); }
  void cancel() {
    if (busy())
      fail("Request cancelled");
  }
  void load(const QUrl &url, int timeoutMs = 3000) {
    discard();
    if (!url.isValid() || url.host().isEmpty() || !url.userInfo().isEmpty() ||
        (url.scheme() != "http" && url.scheme() != "https") || timeoutMs < 1) {
      fail(
          "Expected an HTTP(S) URL without credentials and a positive timeout");
      return;
    }
    QNetworkRequest request(url);
    request.setAttribute(QNetworkRequest::RedirectPolicyAttribute,
                         QNetworkRequest::NoLessSafeRedirectPolicy);
    active_ = manager_.get(request);
    active_->setReadBufferSize(maximumDocumentBytes + 1);
    auto *reply = active_.data();
    const auto generation = generation_;
    connect(reply, &QIODevice::readyRead, this, [this, reply, generation] {
      if (generation == generation_)
        collect(reply);
    });
    connect(reply, &QNetworkReply::finished, this, [this, reply, generation] {
      if (generation != generation_) {
        reply->deleteLater();
        return;
      }
      if (!collect(reply))
        return;
      const auto status =
          reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
      if (reply->error() != QNetworkReply::NoError || status < 200 ||
          status >= 300) {
        fail(QString("HTTP %1: %2").arg(status).arg(reply->errorString()));
        return;
      }
      auto decoded = decode(bytes_);
      if (!succeeded(decoded)) {
        fail(QString::fromStdString(std::get<Error>(decoded).message));
        return;
      }
      auto completed = bytes_;
      discard();
      emit busyChanged(false);
      emit ready(completed);
    });
    deadline_.start(timeoutMs);
    emit busyChanged(true);
  }
signals:
  void ready(const QByteArray &document);
  void failed(const QString &message);
  void busyChanged(bool busy);
};
} // namespace orders
