#pragma once
#include "download.hpp"
#include "order_editor.hpp"
#include <QFileDialog>
#include <QPlainTextEdit>
#include <optional>

namespace orders {
class OrderWindow final : public QWidget {
  OrderService &service_;
  OrderDownload download_{this};
  OrderEditor *editor_;
  QPlainTextEdit *preview_;
  QPushButton *apply_;
  QLabel *status_;
  std::optional<std::vector<Order>> pending_;
  std::vector<Order> beforePreview_;
  void clearPreview() {
    pending_.reset();
    preview_->clear();
    apply_->setEnabled(false);
  }
  void showResult(const Result<Done> &result, const QString &success) {
    status_->setText(succeeded(result) ? success
                                       : QString::fromStdString(
                                             std::get<Error>(result).message));
  }

public:
  explicit OrderWindow(OrderService &service) : service_(service) {
    setWindowTitle("FactoryForge context · Order Lab");
    resize(900, 780);
    auto *layout = new QVBoxLayout(this);
    auto *heading =
        new QLabel("Order Lab · independent C++ / Qt learning project", this);
    heading->setStyleSheet("font-size: 20px; font-weight: bold; padding: 8px");
    layout->addWidget(heading);
    editor_ = new OrderEditor(service_, this);
    layout->addWidget(editor_, 1);
    auto *fileButtons = new QHBoxLayout;
    auto *import = new QPushButton("Preview JSON file", this);
    auto *exportFile = new QPushButton("Export saved orders", this);
    fileButtons->addWidget(import);
    fileButtons->addWidget(exportFile);
    layout->addLayout(fileButtons);
    auto *net = new QHBoxLayout;
    auto *url = new QLineEdit("http://127.0.0.1:8765/orders", this);
    url->setAccessibleName("Import URL");
    url->setObjectName("importUrl");
    auto *fetch = new QPushButton("Preview URL", this);
    fetch->setObjectName("fetch");
    auto *cancel = new QPushButton("Cancel request", this);
    cancel->setEnabled(false);
    net->addWidget(url, 1);
    net->addWidget(fetch);
    net->addWidget(cancel);
    layout->addLayout(net);
    preview_ = new QPlainTextEdit(this);
    preview_->setReadOnly(true);
    preview_->setAccessibleName("Import preview");
    preview_->setMaximumHeight(110);
    layout->addWidget(preview_);
    apply_ = new QPushButton("Replace saved orders with preview", this);
    apply_->setObjectName("applyImport");
    apply_->setEnabled(false);
    layout->addWidget(apply_);
    status_ = new QLabel(
        "Import replaces all saved orders after validation and confirmation.",
        this);
    status_->setWordWrap(true);
    status_->setObjectName("importStatus");
    layout->addWidget(status_);
    connect(import, &QPushButton::clicked, this, [this] {
      const auto path = QFileDialog::getOpenFileName(
          this, "Import order-lab JSON", {}, "JSON (*.json)");
      if (!path.isEmpty()) {
        download_.cancel();
        showResult(stageFile(path),
                   "Preview ready. Review before replacing saved orders.");
      }
    });
    connect(exportFile, &QPushButton::clicked, this, [this] {
      const auto path = QFileDialog::getSaveFileName(
          this, "Export order-lab JSON", "orders.json", "JSON (*.json)");
      if (path.isEmpty())
        return;
      auto loaded = service_.list();
      if (!succeeded(loaded)) {
        showResult(std::get<Error>(loaded), {});
        return;
      }
      showResult(saveFile(path, std::get<std::vector<Order>>(loaded)),
                 "Exported");
    });
    connect(fetch, &QPushButton::clicked, this, [this, url] {
      clearPreview();
      status_->setText("Loading preview...");
      download_.load(QUrl(url->text()));
    });
    connect(cancel, &QPushButton::clicked, &download_, &OrderDownload::cancel);
    connect(&download_, &OrderDownload::busyChanged, cancel,
            &QPushButton::setEnabled);
    connect(&download_, &OrderDownload::failed, status_, &QLabel::setText);
    connect(&download_, &OrderDownload::ready, this,
            [this](const QByteArray &bytes) {
              showResult(
                  stage(bytes),
                  "Preview ready. Review before replacing saved orders.");
            });
    connect(apply_, &QPushButton::clicked, this,
            [this] { showResult(applyPreview(), "Import committed"); });
  }
  Result<Done> stage(const QByteArray &bytes) {
    clearPreview();
    auto decoded = decode(bytes);
    if (!succeeded(decoded))
      return std::get<Error>(decoded);
    auto current = service_.list();
    if (!succeeded(current))
      return std::get<Error>(current);
    beforePreview_ = std::get<std::vector<Order>>(std::move(current));
    pending_ = std::get<std::vector<Order>>(std::move(decoded));
    QStringList lines{QString("%1 orders will replace the saved list:")
                          .arg(pending_->size())};
    for (const auto &order : *pending_)
      lines << QString("%1 | %2 | priority %3 | %4")
                   .arg(order.id)
                   .arg(QString::fromStdString(order.title))
                   .arg(order.priority)
                   .arg(order.status == Status::open ? "open" : "done");
    preview_->setPlainText(lines.join('\n'));
    apply_->setEnabled(true);
    return Done{};
  }
  Result<Done> stageFile(const QString &path) {
    clearPreview();
    auto loaded = loadFile(path);
    if (!succeeded(loaded))
      return std::get<Error>(loaded);
    auto encoded = encode(std::get<std::vector<Order>>(loaded));
    if (!succeeded(encoded))
      return std::get<Error>(encoded);
    return stage(std::get<QByteArray>(encoded));
  }
  Result<Done> applyPreview() {
    if (!pending_)
      return Error{ErrorCode::invalid, "No import preview"};
    auto current = service_.list();
    if (!succeeded(current))
      return std::get<Error>(current);
    if (std::get<std::vector<Order>>(current) != beforePreview_) {
      clearPreview();
      return Error{ErrorCode::invalid,
                   "Saved orders changed. Create a new preview."};
    }
    auto saved = service_.replace(*pending_);
    if (!succeeded(saved))
      return std::get<Error>(saved);
    clearPreview();
    editor_->refresh();
    return Done{};
  }
};
} // namespace orders
