#pragma once
#include "repository.hpp"
#include <QSqlDatabase>
#include <QSqlError>
#include <QSqlQuery>
#include <QUuid>
#include <QVariant>

namespace orders {
class SqliteRepository final : public OrderRepository {
  QString name_ = QUuid::createUuid().toString();
  QSqlDatabase database_;
  std::string startupError_;
  Error failure(const QSqlQuery &query) const {
    return {ErrorCode::storage, query.lastError().text().toStdString()};
  }

public:
  explicit SqliteRepository(const QString &path)
      : database_(QSqlDatabase::addDatabase("QSQLITE", name_)) {
    database_.setDatabaseName(path);
    if (!database_.open()) {
      startupError_ = database_.lastError().text().toStdString();
      return;
    }
    QSqlQuery query(database_);
    if (!query.exec(
            "CREATE TABLE IF NOT EXISTS orders (id INTEGER PRIMARY KEY "
            "CHECK(id BETWEEN 1 AND 1000000), title TEXT NOT NULL "
            "CHECK(length(CAST(title AS BLOB)) BETWEEN 1 AND 80), priority "
            "INTEGER NOT NULL CHECK(priority BETWEEN 0 AND 2), status TEXT NOT "
            "NULL CHECK(status IN ('open', 'done')))"))
      startupError_ = query.lastError().text().toStdString();
  }
  SqliteRepository(const SqliteRepository &) = delete;
  SqliteRepository &operator=(const SqliteRepository &) = delete;
  ~SqliteRepository() override {
    database_.close();
    database_ = QSqlDatabase();
    QSqlDatabase::removeDatabase(name_);
  }
  Result<std::vector<Order>> list() const override {
    if (!startupError_.empty())
      return Error{ErrorCode::storage, startupError_};
    QSqlQuery query(database_);
    if (!query.exec("SELECT id,title,priority,status FROM orders ORDER BY id"))
      return failure(query);
    std::vector<Order> batch;
    while (query.next()) {
      const auto status = query.value(3).toString();
      if (status != "open" && status != "done")
        return Error{ErrorCode::invalid, "Unknown stored status"};
      batch.push_back({query.value(0).toInt(),
                       query.value(1).toString().toStdString(),
                       query.value(2).toInt(),
                       status == "open" ? Status::open : Status::done});
    }
    if (query.lastError().isValid())
      return failure(query);
    auto valid = validateBatch(batch);
    if (!succeeded(valid))
      return std::get<Error>(valid);
    return batch;
  }
  Result<Done> replaceAll(std::span<const Order> batch) override {
    auto valid = validateBatch(batch);
    if (!succeeded(valid))
      return std::get<Error>(valid);
    if (!startupError_.empty())
      return Error{ErrorCode::storage, startupError_};
    if (!database_.transaction())
      return Error{ErrorCode::storage,
                   database_.lastError().text().toStdString()};
    struct Rollback {
      QSqlDatabase &database;
      bool committed{false};
      ~Rollback() {
        if (!committed)
          database.rollback();
      }
    } transaction{database_};
    QSqlQuery query(database_);
    if (!query.exec("DELETE FROM orders"))
      return failure(query);
    if (!query.prepare(
            "INSERT INTO orders(id,title,priority,status) VALUES(?,?,?,?)"))
      return failure(query);
    for (const auto &order : batch) {
      query.bindValue(0, order.id);
      query.bindValue(1, QString::fromStdString(order.title));
      query.bindValue(2, order.priority);
      query.bindValue(3, order.status == Status::open ? "open" : "done");
      if (!query.exec())
        return failure(query);
    }
    if (!database_.commit())
      return Error{ErrorCode::storage,
                   database_.lastError().text().toStdString()};
    transaction.committed = true;
    return Done{};
  }
};
} // namespace orders
