#pragma once
#include "order.hpp"
#include <QFile>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QSaveFile>
#include <cmath>

namespace orders {
inline constexpr int maximumDocumentBytes = 262144;
inline bool integer(const QJsonValue &value, int minimum, int maximum) {
  if (!value.isDouble())
    return false;
  double number = value.toDouble();
  return std::isfinite(number) && std::floor(number) == number &&
         number >= minimum && number <= maximum;
}
inline Result<std::vector<Order>> decode(const QByteArray &bytes) {
  if (bytes.size() > maximumDocumentBytes)
    return Error{ErrorCode::invalid, "Document exceeds 256 KiB"};
  QJsonParseError parse;
  auto document = QJsonDocument::fromJson(bytes, &parse);
  if (parse.error != QJsonParseError::NoError || !document.isObject())
    return Error{ErrorCode::invalid, "Expected a JSON object"};
  auto root = document.object();
  if (root.value("format") != "appfabrik-order-lab" ||
      !integer(root.value("version"), 1, 2))
    return Error{ErrorCode::unsupported,
                 "Expected order-lab format version 1 or 2"};
  if (!root.value("orders").isArray() ||
      root.value("orders").toArray().size() > 1000)
    return Error{ErrorCode::invalid,
                 "Expected an array of at most 1000 orders"};
  std::vector<Order> result;
  for (const auto &value : root.value("orders").toArray()) {
    if (!value.isObject())
      return Error{ErrorCode::invalid, "Order must be an object"};
    auto object = value.toObject();
    if (!integer(object.value("id"), 1, 1000000) ||
        !object.value("title").isString())
      return Error{ErrorCode::invalid, "Invalid ID or title"};
    Order order{object.value("id").toInt(),
                object.value("title").toString().toStdString()};
    if (root.value("version").toInt() == 2) {
      if (!integer(object.value("priority"), 0, 2) ||
          (object.value("status") != "open" &&
           object.value("status") != "done"))
        return Error{ErrorCode::invalid, "Invalid priority or status"};
      order.priority = object.value("priority").toInt();
      order.status =
          object.value("status") == "done" ? Status::done : Status::open;
    }
    result.push_back(std::move(order));
  }
  auto valid = validateBatch(result);
  if (!succeeded(valid))
    return std::get<Error>(valid);
  return result;
}
inline Result<QByteArray> encode(std::span<const Order> batch) {
  auto valid = validateBatch(batch);
  if (!succeeded(valid))
    return std::get<Error>(valid);
  QJsonArray items;
  for (const auto &order : batch)
    items.append(QJsonObject{
        {"id", order.id},
        {"title", QString::fromStdString(order.title)},
        {"priority", order.priority},
        {"status", order.status == Status::open ? "open" : "done"}});
  auto bytes = QJsonDocument(QJsonObject{{"format", "appfabrik-order-lab"},
                                         {"version", 2},
                                         {"orders", items}})
                   .toJson(QJsonDocument::Compact);
  if (bytes.size() > maximumDocumentBytes)
    return Error{ErrorCode::invalid, "Encoded document exceeds 256 KiB"};
  return bytes;
}
inline Result<std::vector<Order>> loadFile(const QString &path) {
  QFile file(path);
  if (!file.open(QIODevice::ReadOnly))
    return Error{ErrorCode::storage, file.errorString().toStdString()};
  auto bytes = file.read(maximumDocumentBytes + 1);
  if (file.error() != QFileDevice::NoError)
    return Error{ErrorCode::storage, file.errorString().toStdString()};
  return decode(bytes);
}
inline Result<Done> saveFile(const QString &path,
                             std::span<const Order> batch) {
  auto encoded = encode(batch);
  if (!succeeded(encoded))
    return std::get<Error>(encoded);
  const auto &bytes = std::get<QByteArray>(encoded);
  QSaveFile file(path);
  file.setDirectWriteFallback(false);
  if (!file.open(QIODevice::WriteOnly) || file.write(bytes) != bytes.size() ||
      !file.commit())
    return Error{ErrorCode::storage, file.errorString().toStdString()};
  return Done{};
}
} // namespace orders
