#include "factory/desktop/main_window.h"
#include "factory/core/puzzles.h"
#include "factory/data/json_project_repository.h"
#include <QAction>
#include <QCloseEvent>
#include <QComboBox>
#include <QDialog>
#include <QDialogButtonBox>
#include <QDir>
#include <QFileDialog>
#include <QFormLayout>
#include <QGroupBox>
#include <QHBoxLayout>
#include <QHeaderView>
#include <QLabel>
#include <QLineEdit>
#include <QListWidget>
#include <QMenuBar>
#include <QMessageBox>
#include <QPushButton>
#include <QSaveFile>
#include <QSettings>
#include <QSignalBlocker>
#include <QSpinBox>
#include <QSplitter>
#include <QStatusBar>
#include <QTableWidget>
#include <QTextStream>
#include <QTimer>
#include <QToolBar>
#include <QVBoxLayout>
#include <algorithm>

namespace factory {
namespace {
void translations(QObject* object, std::pair<const char*, const char*> words) {
  object->setProperty("de", words.first);
  object->setProperty("en", words.second);
}
int nextVehicleId(const Project& p) {
  int next = 1;
  for (const auto& v : p.vehicles)
    next = std::max(next, v.id + 1);
  return next;
}
} // namespace
QString MainWindow::text(const char* de, const char* en) const {
  return QString::fromUtf8(german_ ? de : en);
}
QLabel* MainWindow::label(const char* de, const char* en, QWidget* parent) {
  auto* widget = new QLabel(text(de, en), parent);
  translations(widget, {de, en});
  widget->setWordWrap(true);
  return widget;
}
QPushButton* MainWindow::button(const char* de, const char* en, QWidget* parent) {
  auto* widget = new QPushButton(text(de, en), parent);
  translations(widget, {de, en});
  return widget;
}
QAction* MainWindow::action(const char* de, const char* en, const QKeySequence& shortcut) {
  auto* result = new QAction(text(de, en), this);
  translations(result, {de, en});
  result->setShortcut(shortcut);
  addAction(result);
  return result;
}
MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent), document_(std::make_shared<JsonProjectRepository>()) {
  QSettings settings;
  german_ = settings.value("language", "de").toString() == "de";
  resize(1360, 850);
  setMinimumSize(960, 640);
  setStyleSheet(
      "QMainWindow, QWidget { color: #233247; background: #f7f9fc; font-size: 13px; }"
      "QPushButton { background: white; border: 1px solid #cdd7e2; border-radius: 6px; padding: "
      "8px 12px; }"
      "QPushButton:hover { border-color: #23856d; background: #edf7f3; }"
      "QPushButton:disabled { color: #8794a7; background: #edf0f5; }"
      "QPushButton#play { background: #23856d; color: white; border: none; font-weight: bold; }"
      "QGroupBox { font-weight: bold; border: 1px solid #dce3ed; border-radius: 8px; margin-top: "
      "12px; padding-top: 12px; }"
      "QGroupBox::title { subcontrol-origin: margin; left: 12px; padding: 0 4px; }"
      "QLineEdit, QSpinBox, QComboBox { background: white; border: 1px solid #cdd7e2; "
      "border-radius: 4px; padding: 5px; }"
      "QListWidget, QTableWidget { background: white; border: 1px solid #dce3ed; border-radius: "
      "4px; }"
      "QToolBar { spacing: 6px; padding: 8px; border-bottom: 1px solid #dce3ed; }"
      "QLabel#brand { font-size: 25px; font-weight: bold; color: #1a3856; }"
      "QLabel#guidance { background: #e6f2ed; border-radius: 8px; padding: 12px; color: #1d5b4c; }"
      "QLabel#metrics { font-size: 15px; font-weight: bold; padding: 12px; background: white; "
      "border-radius: 6px; }");

  auto* toolbar = addToolBar("Project");
  toolbar->setMovable(false);
  auto* newAction = action("Neue Karte", "New map", QKeySequence::New);
  auto* openAction = action("Öffnen", "Open", QKeySequence::Open);
  auto* saveAction = action("Speichern", "Save", QKeySequence::Save);
  auto* saveAsAction = action("Speichern unter", "Save as", QKeySequence::SaveAs);
  undo_ = action("Rückgängig", "Undo", QKeySequence::Undo);
  redo_ = action("Wiederholen", "Redo", QKeySequence::Redo);
  undo_->setObjectName("undo");
  redo_->setObjectName("redo");
  for (auto* entry : {newAction, openAction, saveAction, saveAsAction, undo_, redo_})
    toolbar->addAction(entry);
  toolbar->addSeparator();
  auto* fit = action("Karte einpassen", "Fit map", QKeySequence("Ctrl+0"));
  toolbar->addAction(fit);
  auto* help = action("Spielanleitung", "How to play", QKeySequence::HelpContents);
  toolbar->addAction(help);
  auto* language = new QPushButton("DE / EN", this);
  language->setObjectName("language");
  toolbar->addWidget(language);
  connect(newAction, &QAction::triggered, this, &MainWindow::newMap);
  connect(openAction, &QAction::triggered, this, &MainWindow::openFile);
  connect(saveAction, &QAction::triggered, this, [this] { saveFile(); });
  connect(saveAsAction, &QAction::triggered, this, [this] { saveFile(true); });
  connect(undo_, &QAction::triggered, this, [this] {
    document_.undo();
    syncEditor();
  });
  connect(redo_, &QAction::triggered, this, [this] {
    document_.redo();
    syncEditor();
  });
  connect(fit, &QAction::triggered, this, [this] { board_->fitBoard(); });
  connect(help, &QAction::triggered, this, &MainWindow::showHelp);
  connect(language, &QPushButton::clicked, this, [this] { setGerman(!german_); });

  auto* central = new QWidget(this);
  auto* outer = new QVBoxLayout(central);
  outer->setContentsMargins(18, 14, 18, 14);
  auto* heading = label("FactoryForge", "FactoryForge");
  heading->setObjectName("brand");
  outer->addWidget(heading);
  outer->addWidget(label("Lager planen. Lieferungen verbinden. Engpässe lösen.",
                         "Plan a warehouse. Connect deliveries. Solve bottlenecks."));
  auto* splitter = new QSplitter(Qt::Horizontal, central);
  outer->addWidget(splitter, 1);
  auto* left = new QWidget;
  left->setMaximumWidth(285);
  auto* leftLayout = new QVBoxLayout(left);
  leftLayout->setContentsMargins(0, 12, 12, 0);
  leftLayout->addWidget(label("AUFGABE", "PUZZLE"));
  puzzles_ = new QComboBox;
  puzzles_->setObjectName("puzzles");
  for (int i = 0; i < PuzzleCount; ++i)
    puzzles_->addItem(QString::fromStdString(puzzleTitle(i, german_)));
  puzzles_->addItem(text("Eigene Karte", "Custom map"));
  leftLayout->addWidget(puzzles_);
  guidance_ = new QLabel;
  guidance_->setWordWrap(true);
  guidance_->setObjectName("guidance");
  leftLayout->addWidget(guidance_);
  leftLayout->addWidget(label("BAUWERKZEUG", "BUILD TOOL"));
  tools_ = new QComboBox;
  tools_->setObjectName("tools");
  const std::vector<std::pair<const char*, const char*>> toolLabels{
      {"Boden / Entfernen", "Floor / Erase"},
      {"Transportweg", "Road"},
      {"Hindernis", "Obstacle"},
      {"Wareneingang", "Inbound"},
      {"Lagerplatz", "Storage"},
      {"Warenausgang", "Outbound"},
      {"Fahrzeug platzieren", "Place vehicle"},
      {"Fahrzeug entfernen", "Remove vehicle"},
      {"Auswählen", "Select"}};
  for (const auto& [de, en] : toolLabels) {
    tools_->addItem(text(de, en));
    const int i = tools_->count() - 1;
    tools_->setItemData(i, de, Qt::UserRole + 1);
    tools_->setItemData(i, en, Qt::UserRole + 2);
  }
  tools_->setCurrentIndex(1);
  leftLayout->addWidget(tools_);
  leftLayout->addWidget(
      label("Links ziehen: bauen. Rechts ziehen: entfernen. Mausrad: zoomen. Strg + Ziehen: Karte "
            "verschieben.",
            "Drag left: build. Drag right: erase. Wheel: zoom. Ctrl + drag: pan."));
  selection_ = new QLabel;
  selection_->setWordWrap(true);
  leftLayout->addWidget(selection_);
  auto* goals = new QGroupBox(text("Projekt und Ziele", "Project and goals"));
  translations(goals, {"Projekt und Ziele", "Project and goals"});
  auto* form = new QFormLayout(goals);
  name_ = new QLineEdit;
  name_->setObjectName("projectName");
  tickLimit_ = new QSpinBox;
  tickLimit_->setRange(1, 1000000);
  roadBudget_ = new QSpinBox;
  roadBudget_->setRange(0, 16384);
  vehicleBudget_ = new QSpinBox;
  vehicleBudget_->setRange(1, 50);
  form->addRow(label("Name", "Name"), name_);
  form->addRow(label("Zeitlimit (Ticks)", "Deadline (ticks)"), tickLimit_);
  form->addRow(label("Wegebudget", "Road budget"), roadBudget_);
  form->addRow(label("Fahrzeugbudget", "Vehicle budget"), vehicleBudget_);
  leftLayout->addWidget(goals);
  auto* check = button("Aufbau prüfen", "Validate layout");
  check->setObjectName("validate");
  leftLayout->addWidget(check);
  auto* solution = button("Musterlösung öffnen", "Open reference solution");
  leftLayout->addWidget(solution);
  leftLayout->addStretch();
  splitter->addWidget(left);

  auto* middle = new QWidget;
  auto* middleLayout = new QVBoxLayout(middle);
  middleLayout->setContentsMargins(0, 12, 0, 0);
  board_ = new BoardView;
  middleLayout->addWidget(board_, 1);
  auto* controls = new QHBoxLayout;
  play_ = button("Starten", "Start");
  play_->setObjectName("play");
  step_ = button("Einzelschritt", "Single step");
  step_->setObjectName("step");
  edit_ = button("Zurück zum Editor", "Back to editor");
  edit_->setObjectName("edit");
  auto* reset = button("Zurücksetzen", "Reset");
  reset->setObjectName("reset");
  speed_ = new QComboBox;
  speed_->addItems({"1×", "2×", "4×"});
  for (auto* widget : std::vector<QWidget*>{play_, step_, reset, edit_, speed_})
    controls->addWidget(widget);
  middleLayout->addLayout(controls);
  metrics_ = new QLabel;
  metrics_->setWordWrap(true);
  metrics_->setObjectName("metrics");
  middleLayout->addWidget(metrics_);
  splitter->addWidget(middle);

  auto* right = new QWidget;
  right->setMaximumWidth(320);
  auto* rightLayout = new QVBoxLayout(right);
  rightLayout->setContentsMargins(12, 12, 0, 0);
  rightLayout->addWidget(label("LIEFERAUFTRÄGE", "DELIVERY ORDERS"));
  orders_ = new QTableWidget;
  orders_->setObjectName("orders");
  orders_->setColumnCount(3);
  orders_->setSelectionBehavior(QAbstractItemView::SelectRows);
  orders_->setEditTriggers(QAbstractItemView::NoEditTriggers);
  orders_->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
  orders_->verticalHeader()->hide();
  rightLayout->addWidget(orders_, 1);
  addOrder_ = button("Auftrag hinzufügen", "Add order");
  removeOrder_ = button("Auftrag entfernen", "Remove order");
  rightLayout->addWidget(addOrder_);
  rightLayout->addWidget(removeOrder_);
  rightLayout->addWidget(label("PRÜFUNG UND WARTEZEITEN", "VALIDATION AND WAITING"));
  issues_ = new QListWidget;
  issues_->setWordWrap(true);
  issues_->setMinimumHeight(120);
  rightLayout->addWidget(issues_, 1);
  auto* exportButton = button("Ergebnis als CSV", "Export result CSV");
  rightLayout->addWidget(exportButton);
  splitter->addWidget(right);
  splitter->setStretchFactor(1, 1);
  splitter->setChildrenCollapsible(false);
  splitter->setSizes({280, 760, 280});
  setCentralWidget(central);

  board_->clicked = [this](Position pos, bool erase) { cellClicked(pos, erase); };
  connect(puzzles_, &QComboBox::activated, this, [this](int index) {
    if (!confirmDiscard()) {
      const QSignalBlocker blocker(puzzles_);
      puzzles_->setCurrentIndex(document_.project().puzzleId < 0 ? 5
                                                                 : document_.project().puzzleId);
      return;
    }
    if (index == 5) {
      document_.replace(Project{});
      setProject(document_.project());
    } else
      setProject(makePuzzle(index));
  });
  connect(name_, &QLineEdit::textEdited, this, [this] {
    document_.edit([this](Project& p) { p.name = name_->text().toStdString(); });
    refresh();
  });
  for (auto* spin : {tickLimit_, roadBudget_, vehicleBudget_})
    connect(spin, &QSpinBox::valueChanged, this, [this] {
      document_.edit([this](Project& p) {
        p.tickLimit = tickLimit_->value();
        p.roadBudget = roadBudget_->value();
        p.vehicleBudget = vehicleBudget_->value();
      });
      refresh();
    });
  connect(check, &QPushButton::clicked, this, [this] {
    issues_->clear();
    const auto issues = preflight(document_.project());
    for (const auto& issue : issues)
      issues_->addItem(issueText(issue));
    if (issues.empty())
      issues_->addItem(
          text("Aufbau gültig. Bereit für den Start.", "Valid layout. Ready to start."));
  });
  connect(solution, &QPushButton::clicked, this, [this] {
    const int id = document_.project().puzzleId;
    if (id >= 0 && confirmDiscard())
      setProject(makePuzzle(id, true));
  });
  connect(play_, &QPushButton::clicked, this, [this] {
    if (!simulation_.active())
      startSimulation();
    else
      simulation_.setPlaying(!simulation_.playing());
    refresh();
  });
  connect(step_, &QPushButton::clicked, this, [this] {
    if (!simulation_.active() && !startSimulation())
      return;
    simulation_.setPlaying(false);
    simulation_.stepOnce();
    refresh();
  });
  connect(edit_, &QPushButton::clicked, this, [this] {
    simulation_.stop();
    syncEditor();
  });
  connect(reset, &QPushButton::clicked, this, [this] {
    if (simulation_.active()) {
      simulation_.start(document_.project(), false);
      wonRecorded_ = false;
    }
    refresh();
  });
  connect(speed_, &QComboBox::currentIndexChanged, this,
          [this](int i) { simulation_.setSpeed(1 << i); });
  connect(addOrder_, &QPushButton::clicked, this, [this] { editOrders(false); });
  connect(removeOrder_, &QPushButton::clicked, this, [this] { editOrders(true); });
  connect(exportButton, &QPushButton::clicked, this, &MainWindow::exportResults);
  timer_ = new QTimer(this);
  connect(timer_, &QTimer::timeout, this, &MainWindow::refresh);
  timer_->start(50);
  setProject(makePuzzle(0));
  setGerman(german_);
  QTimer::singleShot(0, this, [this] { board_->fitBoard(); });
}
MainWindow::~MainWindow() { simulation_.stop(); }
void MainWindow::setProject(Project project) {
  simulation_.stop();
  document_.replace(std::move(project));
  wonRecorded_ = false;
  issues_->clear();
  syncEditor();
  board_->fitBoard();
}
void MainWindow::syncEditor() {
  const auto& p = document_.project();
  const QSignalBlocker nameBlock(name_), tickBlock(tickLimit_), roadBlock(roadBudget_),
      vehicleBlock(vehicleBudget_), puzzleBlock(puzzles_);
  name_->setText(
      QString::fromStdString(p.puzzleId < 0 ? p.name : puzzleTitle(p.puzzleId, german_)));
  tickLimit_->setValue(p.tickLimit);
  roadBudget_->setValue(p.roadBudget);
  vehicleBudget_->setValue(p.vehicleBudget);
  puzzles_->setCurrentIndex(p.puzzleId < 0 ? 5 : p.puzzleId);
  orders_->setRowCount(static_cast<int>(p.orders.size()));
  for (int i = 0; i < orders_->rowCount(); ++i) {
    const auto& order = p.orders.at(static_cast<std::size_t>(i));
    orders_->setItem(i, 0, new QTableWidgetItem(QString::number(order.id)));
    orders_->setItem(
        i, 1, new QTableWidgetItem(QString("%1,%2").arg(order.pickup.x).arg(order.pickup.y)));
    orders_->setItem(
        i, 2, new QTableWidgetItem(QString("%1,%2").arg(order.delivery.x).arg(order.delivery.y)));
  }
  refresh();
}
QString MainWindow::issueText(const std::string& issue) const {
  QString result = QString::fromStdString(issue);
  if (!german_)
    return result;
  const std::vector<std::pair<const char*, const char*>> phrases{
      {"Vehicle ", "Fahrzeug "},
      {"Order ", "Auftrag "},
      {"no connected route", "kein verbundener Weg"},
      {"waiting for a reserved route", "wartet auf einen freien Weg"},
      {"connect pickup and delivery with roads", "Abholung und Ziel mit Wegen verbinden"},
      {"no vehicle can reach the pickup", "kein Fahrzeug erreicht die Abholung"},
      {"Road budget exceeded", "Wegebudget überschritten"},
      {"Add 1..10000 delivery orders", "1 bis 10000 Lieferaufträge hinzufügen"},
      {"Vehicle budget must allow 1..50 vehicles",
       "1 bis 50 Fahrzeuge innerhalb des Budgets platzieren"},
      {"Vehicles need unique IDs and distinct traversable home cells",
       "Fahrzeuge benötigen eindeutige Nummern und eigene Startfelder auf Wegen"},
      {"Orders must connect source/storage to sink/storage",
       "Aufträge müssen Eingang/Lager mit Ausgang/Lager verbinden"},
      {"Project needs a name of 1..200 bytes",
       "Projekt benötigt einen Namen mit 1 bis 200 UTF-8-Bytes"},
      {"Orders need unique IDs and distinct valid endpoints",
       "Aufträge benötigen eindeutige Nummern und verschiedene gültige Ziele"},
      {"Tick limit must be 1..1000000", "Zeitlimit muss 1 bis 1000000 Ticks betragen"}};
  for (const auto& [en, de] : phrases)
    result.replace(QString::fromUtf8(en), QString::fromUtf8(de));
  return result;
}
void MainWindow::refresh() {
  const auto& p = document_.project();
  const bool active = simulation_.active();
  const auto snapshot = simulation_.snapshot();
  board_->display(p, snapshot);
  const bool custom = p.puzzleId < 0;
  for (auto* widget : std::vector<QWidget*>{name_, tickLimit_, roadBudget_, vehicleBudget_,
                                            addOrder_, removeOrder_})
    widget->setEnabled(custom && !active);
  tools_->setEnabled(!active);
  undo_->setEnabled(!active && document_.canUndo());
  redo_->setEnabled(!active && document_.canRedo());
  edit_->setEnabled(active);
  step_->setEnabled(!simulation_.playing() && (!active || snapshot.outcome == Outcome::Running));
  play_->setEnabled(!active || snapshot.outcome == Outcome::Running);
  play_->setText(!active                 ? text("Starten", "Start")
                 : simulation_.playing() ? text("Pause", "Pause")
                                         : text("Fortsetzen", "Resume"));
  QString outcome = text("Entwurf", "Editing");
  if (active)
    outcome = snapshot.outcome == Outcome::Won    ? text("Aufgabe gelöst!", "Puzzle solved!")
              : snapshot.outcome == Outcome::Lost ? text("Zeitlimit erreicht", "Deadline reached")
              : simulation_.playing()             ? text("Simulation läuft", "Simulation running")
                                                  : text("Pausiert", "Paused");
  metrics_->setText(QString("%1\n%2: %3 / %4    %5: %6 / %7    %8: %9")
                        .arg(outcome, text("Lieferungen", "Deliveries"))
                        .arg(snapshot.delivered)
                        .arg(p.orders.size())
                        .arg(text("Ticks", "Ticks"))
                        .arg(snapshot.tick)
                        .arg(p.tickLimit)
                        .arg(text("Warten", "Waiting"))
                        .arg(snapshot.waitingTicks));
  guidance_->setText(
      QString(text("Verbinde die markierten Stationen mit Wegen. Blau sind Fahrzeuge. Liefere alle "
                   "Aufträge innerhalb des Limits.\n\nWege: %1 / %2\nFahrzeuge: %3 / %4",
                   "Connect the marked stations with roads. Blue circles are vehicles. Deliver "
                   "every order before the deadline.\n\nRoads: %1 / %2\nVehicles: %3 / %4"))
          .arg(p.roadCount())
          .arg(p.roadBudget)
          .arg(p.vehicles.size())
          .arg(p.vehicleBudget));
  if (active) {
    issues_->clear();
    for (const auto& issue : snapshot.diagnostics)
      issues_->addItem(issueText(issue));
    if (snapshot.outcome == Outcome::Won && !wonRecorded_ && isOfficialPuzzle(p)) {
      QSettings settings;
      settings.setValue(QString("puzzles/%1/solved").arg(p.puzzleId), true);
      const QString key = QString("puzzles/%1/bestTicks").arg(p.puzzleId);
      settings.setValue(key, std::min(settings.value(key, p.tickLimit + 1).toInt(), snapshot.tick));
      wonRecorded_ = true;
    }
  }
  setWindowTitle(
      QString("FactoryForge — %1%2")
          .arg(QString::fromStdString(p.puzzleId < 0 ? p.name : puzzleTitle(p.puzzleId, german_)),
               document_.dirty() ? " *" : ""));
  statusBar()->showMessage(
      QString("%1 × %2  ·  %3")
          .arg(p.width)
          .arg(p.height)
          .arg(document_.dirty() ? text("Ungespeicherte Änderungen", "Unsaved changes")
                                 : text("Gespeicherter Ausgangsaufbau", "Saved starting layout")));
}
void MainWindow::cellClicked(Position position, bool erase) {
  selected_ = position;
  selection_->setText(
      QString("%1: %2, %3").arg(text("Feld", "Cell")).arg(position.x).arg(position.y));
  if (simulation_.active())
    return;
  int tool = erase ? 0 : tools_->currentIndex();
  const auto& current = document_.project();
  if (tool == 8)
    return;
  if (current.puzzleId >= 0) {
    const auto base = makePuzzle(current.puzzleId);
    if (tool != 0 && tool != 1 && tool != 6 && tool != 7)
      return;
    if (base.tile(position) != Tile::Floor && base.tile(position) != Tile::Road)
      return;
  }
  document_.edit([&](Project& p) {
    if (tool == 6) {
      if (!p.traversable(position) ||
          p.vehicles.size() >= static_cast<std::size_t>(p.vehicleBudget))
        return;
      if (std::ranges::none_of(p.vehicles, [&](const auto& v) { return v.home == position; }))
        p.vehicles.push_back({nextVehicleId(p), position});
    } else if (tool == 7)
      std::erase_if(p.vehicles, [&](const auto& v) { return v.home == position; });
    else {
      if (tool == 1 && p.tile(position) != Tile::Road && p.roadCount() >= p.roadBudget)
        return;
      p.setTile(position, static_cast<Tile>(tool));
    }
  });
  refresh();
}
bool MainWindow::startSimulation(bool showErrors) {
  const auto issues = preflight(document_.project());
  if (!issues.empty()) {
    issues_->clear();
    for (const auto& issue : issues)
      issues_->addItem(issueText(issue));
    if (showErrors)
      QMessageBox::information(
          this, text("Aufbau prüfen", "Validate layout"),
          text("Der Aufbau braucht noch Änderungen. Sieh dir die Hinweise rechts an.",
               "The layout needs changes. Review the issues on the right."));
    return false;
  }
  simulation_.start(document_.project());
  wonRecorded_ = false;
  refresh();
  return true;
}
void MainWindow::openFile() {
  if (!confirmDiscard())
    return;
  const auto path = QFileDialog::getOpenFileName(this, text("Projekt öffnen", "Open project"), {},
                                                 "FactoryForge (*.factoryforge)");
  if (path.isEmpty())
    return;
  try {
    document_.load(path.toStdString());
    simulation_.stop();
    syncEditor();
    board_->fitBoard();
  } catch (const std::exception& error) {
    QMessageBox::warning(this, text("Öffnen fehlgeschlagen", "Open failed"),
                         QString::fromUtf8(error.what()));
  }
}
bool MainWindow::saveFile(bool saveAs) {
  auto path = QString::fromStdString(document_.path());
  if (saveAs || path.isEmpty())
    path = QFileDialog::getSaveFileName(this, text("Projekt speichern", "Save project"), path,
                                        "FactoryForge (*.factoryforge)");
  if (path.isEmpty())
    return false;
  if (!path.endsWith(".factoryforge"))
    path += ".factoryforge";
  try {
    document_.save(path.toStdString());
    refresh();
    return true;
  } catch (const std::exception& error) {
    QMessageBox::warning(this, text("Speichern fehlgeschlagen", "Save failed"),
                         QString::fromUtf8(error.what()));
    return false;
  }
}
bool MainWindow::confirmDiscard() {
  if (!document_.dirty())
    return true;
  const auto result = QMessageBox::question(
      this, text("Entwurf speichern?", "Save your draft?"),
      text("Dieser Entwurf enthält ungespeicherte Änderungen.",
           "This draft contains unsaved changes."),
      QMessageBox::Save | QMessageBox::Discard | QMessageBox::Cancel, QMessageBox::Save);
  return result == QMessageBox::Discard || (result == QMessageBox::Save && saveFile());
}
void MainWindow::closeEvent(QCloseEvent* event) {
  if (confirmDiscard()) {
    simulation_.stop();
    event->accept();
  } else
    event->ignore();
}
void MainWindow::newMap() {
  if (!confirmDiscard())
    return;
  QDialog dialog(this);
  dialog.setWindowTitle(text("Neue Lagerkarte", "New warehouse map"));
  QFormLayout layout(&dialog);
  QSpinBox width, height;
  width.setRange(3, 128);
  height.setRange(3, 128);
  width.setValue(32);
  height.setValue(24);
  layout.addRow(text("Breite", "Width"), &width);
  layout.addRow(text("Höhe", "Height"), &height);
  QDialogButtonBox buttons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
  layout.addRow(&buttons);
  connect(&buttons, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
  connect(&buttons, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
  if (dialog.exec() != QDialog::Accepted)
    return;
  Project p;
  p.name = text("Mein Lager", "My warehouse").toStdString();
  p.width = width.value();
  p.height = height.value();
  p.tiles.assign(static_cast<std::size_t>(p.width) * static_cast<std::size_t>(p.height),
                 Tile::Floor);
  p.roadBudget = p.width * p.height;
  setProject(std::move(p));
}
void MainWindow::editOrders(bool remove) {
  if (document_.project().puzzleId >= 0 || simulation_.active())
    return;
  if (remove) {
    const int row = orders_->currentRow();
    if (row >= 0)
      document_.edit([row](Project& p) { p.orders.erase(p.orders.begin() + row); });
    syncEditor();
    return;
  }
  QDialog dialog(this);
  dialog.setWindowTitle(text("Lieferauftrag", "Delivery order"));
  QFormLayout layout(&dialog);
  QSpinBox px, py, dx, dy;
  for (auto* spin : {&px, &dx})
    spin->setRange(0, document_.project().width - 1);
  for (auto* spin : {&py, &dy})
    spin->setRange(0, document_.project().height - 1);
  px.setValue(selected_.x);
  py.setValue(selected_.y);
  layout.addRow(text("Abholung X", "Pickup X"), &px);
  layout.addRow(text("Abholung Y", "Pickup Y"), &py);
  layout.addRow(text("Ziel X", "Delivery X"), &dx);
  layout.addRow(text("Ziel Y", "Delivery Y"), &dy);
  QDialogButtonBox buttons(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
  layout.addRow(&buttons);
  connect(&buttons, &QDialogButtonBox::accepted, &dialog, &QDialog::accept);
  connect(&buttons, &QDialogButtonBox::rejected, &dialog, &QDialog::reject);
  if (dialog.exec() != QDialog::Accepted)
    return;
  const Position pickup{px.value(), py.value()}, delivery{dx.value(), dy.value()};
  if (pickup == delivery) {
    QMessageBox::information(this, text("Auftrag prüfen", "Check order"),
                             text("Abholung und Ziel müssen verschiedene Felder sein.",
                                  "Pickup and delivery must use different cells."));
    return;
  }
  document_.edit([&](Project& p) {
    int id = 1;
    for (const auto& order : p.orders)
      id = std::max(id, order.id + 1);
    p.orders.push_back({id, pickup, delivery});
  });
  syncEditor();
}
void MainWindow::exportResults() {
  if (!simulation_.active())
    return;
  const auto path =
      QFileDialog::getSaveFileName(this, text("Ergebnis exportieren", "Export result"),
                                   "factoryforge-results.csv", "CSV (*.csv)");
  if (path.isEmpty())
    return;
  QSaveFile file(path);
  if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
    QMessageBox::warning(this, text("Export fehlgeschlagen", "Export failed"), file.errorString());
    return;
  }
  const auto s = simulation_.snapshot();
  QTextStream stream(&file);
  stream << "tick,delivered,total_orders,waiting_ticks,blocked_vehicles,outcome\n"
         << s.tick << ',' << s.delivered << ',' << document_.project().orders.size() << ','
         << s.waitingTicks << ',' << s.blocked << ',' << static_cast<int>(s.outcome) << '\n';
  stream.flush();
  if (!file.commit())
    QMessageBox::warning(this, text("Export fehlgeschlagen", "Export failed"), file.errorString());
}
void MainWindow::setGerman(bool german) {
  german_ = german;
  QSettings().setValue("language", german_ ? "de" : "en");
  for (auto* object : findChildren<QObject*>()) {
    if (!object->property("de").isValid())
      continue;
    const auto value = object->property(german_ ? "de" : "en").toString();
    if (auto* widget = qobject_cast<QLabel*>(object))
      widget->setText(value);
    else if (auto* push = qobject_cast<QPushButton*>(object))
      push->setText(value);
    else if (auto* group = qobject_cast<QGroupBox*>(object))
      group->setTitle(value);
    else if (auto* entry = qobject_cast<QAction*>(object))
      entry->setText(value);
  }
  for (int i = 0; i < tools_->count(); ++i)
    tools_->setItemText(
        i, tools_->itemData(i, german_ ? Qt::UserRole + 1 : Qt::UserRole + 2).toString());
  for (int i = 0; i < PuzzleCount; ++i) {
    const bool solved = QSettings().value(QString("puzzles/%1/solved").arg(i), false).toBool();
    puzzles_->setItemText(i,
                          (solved ? "✓ " : "") + QString::fromStdString(puzzleTitle(i, german_)));
  }
  puzzles_->setItemText(5, text("Eigene Karte", "Custom map"));
  orders_->setHorizontalHeaderLabels({"ID", text("Abholung", "Pickup"), text("Ziel", "Delivery")});
  board_->setGerman(german_);
  syncEditor();
}
void MainWindow::showHelp() {
  QMessageBox::information(
      this, text("So spielst du", "How to play"),
      text("1. Wähle eine Aufgabe oder erstelle eine eigene Karte.\n2. Verbinde Eingang (E), Lager "
           "(L) und Ausgang (A) mit Wegen. Fahrzeuge starten auf ihrem blauen Feld.\n3. Prüfe den "
           "Aufbau und starte die Simulation. Alle Aufträge müssen vor dem Zeitlimit geliefert "
           "werden.\n4. Bei Wartezeiten helfen parallele Wege und freie Ladeplätze. Zurück zum "
           "Editor beendet den Lauf.\n\nEigene Karten: Platziere Stationen und Fahrzeuge. Trage "
           "Lieferaufträge mit den angezeigten Feldkoordinaten ein. Ein Tick entspricht 0,1 "
           "Sekunden Simulationszeit.\n\nDie Musterlösung ist eine Hilfe zum Lernen. Projekte "
           "speichern den Ausgangsaufbau, nicht einen laufenden Simulationsstand.",
           "1. Choose a puzzle or create a custom map.\n2. Connect inbound (IN), storage (ST) and "
           "outbound (OUT) with roads. Vehicles start on their blue cells.\n3. Validate and start. "
           "Deliver every order before the deadline.\n4. Parallel roads and clear loading ports "
           "reduce waiting. Back to editor ends the run.\n\nCustom maps: place stations and "
           "vehicles, then add orders using cell coordinates. One tick equals 0.1 seconds of "
           "simulation time.\n\nThe reference solution is a learning aid. Projects save the "
           "starting layout, not a running simulation."));
}
void MainWindow::capture(const QString& directory) {
  QDir().mkpath(directory);
  setGerman(true);
  setProject(makePuzzle(3, true));
  board_->fitBoard();
  grab().save(directory + "/factoryforge-editor.png");
  simulation_.start(document_.project(), false);
  for (int i = 0; i < 25; ++i)
    simulation_.stepOnce();
  refresh();
  grab().save(directory + "/factoryforge-simulation.png");
  while (simulation_.snapshot().outcome == Outcome::Running)
    simulation_.stepOnce();
  refresh();
  grab().save(directory + "/factoryforge-result.png");
  simulation_.stop();
}
} // namespace factory
