#include "factory/data/json_project_repository.h"
#include <QFile>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QSaveFile>
#include <cmath>
#include <limits>
#include <set>
#include <stdexcept>

namespace factory {
namespace {
[[noreturn]] void fail(const QString& error) { throw std::runtime_error(error.toStdString()); }
int integer(const QJsonObject& object, const char* key, int minimum, int maximum) {
  const auto value = object.value(QLatin1String(key));
  const double number = value.toDouble(std::numeric_limits<double>::quiet_NaN());
  if (!value.isDouble() || !std::isfinite(number) || std::floor(number) != number ||
      number < minimum || number > maximum)
    fail(QString("Invalid integer: %1").arg(key));
  return static_cast<int>(number);
}
Position position(const QJsonObject& object, const Project& project) {
  return {integer(object, "x", 0, project.width - 1), integer(object, "y", 0, project.height - 1)};
}
QJsonObject encodePosition(Position position) { return {{"x", position.x}, {"y", position.y}}; }
QJsonObject object(const QJsonValue& value) {
  if (!value.isObject())
    fail("Expected an object");
  return value.toObject();
}
QJsonArray array(const QJsonObject& value, const char* key, int maximum) {
  const auto found = value.value(QLatin1String(key));
  if (!found.isArray() || found.toArray().size() > maximum)
    fail(QString("Invalid array: %1").arg(key));
  return found.toArray();
}
} // namespace
QByteArray JsonProjectRepository::encode(const Project& p) {
  QJsonArray tiles, vehicles, orders;
  for (auto tile : p.tiles)
    tiles.append(QString::fromStdString(tileName(tile)));
  for (const auto& v : p.vehicles)
    vehicles.append(QJsonObject{{"id", v.id}, {"home", encodePosition(v.home)}});
  for (const auto& o : p.orders)
    orders.append(QJsonObject{{"id", o.id},
                              {"pickup", encodePosition(o.pickup)},
                              {"delivery", encodePosition(o.delivery)}});
  const QJsonObject root{{"formatVersion", 1},
                         {"name", QString::fromStdString(p.name)},
                         {"width", p.width},
                         {"height", p.height},
                         {"tiles", tiles},
                         {"vehicles", vehicles},
                         {"orders", orders},
                         {"tickLimit", p.tickLimit},
                         {"roadBudget", p.roadBudget},
                         {"vehicleBudget", p.vehicleBudget},
                         {"puzzleId", p.puzzleId}};
  return QJsonDocument(root).toJson(QJsonDocument::Indented);
}
Project JsonProjectRepository::decode(const QByteArray& bytes) {
  if (bytes.size() > qint64{4} * 1024 * 1024)
    fail("Project exceeds 4 MiB");
  QJsonParseError error;
  const auto json = QJsonDocument::fromJson(bytes, &error);
  if (error.error != QJsonParseError::NoError || !json.isObject())
    fail("Project is not a valid JSON object");
  const auto root = json.object();
  if (integer(root, "formatVersion", 1, 1000000) != 1)
    fail("Unsupported project format version");
  Project p;
  if (!root.value("name").isString())
    fail("Missing project name");
  p.name = root.value("name").toString().toStdString();
  if (p.name.empty() || p.name.size() > 200)
    fail("Project name must have 1..200 bytes");
  p.width = integer(root, "width", 3, 128);
  p.height = integer(root, "height", 3, 128);
  p.tickLimit = integer(root, "tickLimit", 1, 1000000);
  p.roadBudget = integer(root, "roadBudget", 0, 16384);
  p.vehicleBudget = integer(root, "vehicleBudget", 1, 50);
  p.puzzleId = integer(root, "puzzleId", -1, 4);
  const auto tiles = array(root, "tiles", 16384);
  if (tiles.size() != qsizetype{p.width} * p.height)
    fail("Tile count does not match dimensions");
  p.tiles.clear();
  for (const auto& value : tiles) {
    if (!value.isString())
      fail("Tile type must be text");
    p.tiles.push_back(tileFromName(value.toString().toStdString()));
  }
  std::set<int> ids;
  std::set<Position> homes;
  for (const auto& value : array(root, "vehicles", 50)) {
    const auto v = object(value);
    VehicleSpec vehicle{integer(v, "id", 1, 1000000), position(object(v.value("home")), p)};
    if (!ids.insert(vehicle.id).second || !homes.insert(vehicle.home).second)
      fail("Duplicate vehicle or home cell");
    p.vehicles.push_back(vehicle);
  }
  ids.clear();
  for (const auto& value : array(root, "orders", 10000)) {
    const auto o = object(value);
    Order order{integer(o, "id", 1, 1000000), position(object(o.value("pickup")), p),
                position(object(o.value("delivery")), p)};
    if (!ids.insert(order.id).second || order.pickup == order.delivery)
      fail("Duplicate order or identical endpoints");
    p.orders.push_back(order);
  }
  return p;
}
Project JsonProjectRepository::load(const std::string& path) const {
  QFile file(QString::fromStdString(path));
  if (!file.open(QIODevice::ReadOnly))
    fail(file.errorString());
  if (file.size() > qint64{4} * 1024 * 1024)
    fail("Project exceeds 4 MiB");
  return decode(file.readAll());
}
void JsonProjectRepository::save(const Project& project, const std::string& path) const {
  const auto bytes = encode(project);
  (void)decode(bytes); // Drafts may be incomplete, but their structure must round-trip safely.
  QSaveFile file(QString::fromStdString(path));
  file.setDirectWriteFallback(false);
  if (!file.open(QIODevice::WriteOnly))
    fail(file.errorString());
  if (file.write(bytes) != bytes.size() || !file.commit())
    fail(file.errorString());
}
} // namespace factory
