#include <algorithm>
#include <chrono>
#include <cstdint>
#include <expected>
#include <filesystem>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>

#include <boost/asio/any_io_executor.hpp>
#include <boost/asio/awaitable.hpp>
#include <boost/asio/post.hpp>
#include <boost/asio/use_awaitable.hpp>

#include <noto.hpp>

#include <vamp_zero/database.hpp>
#include <vamp_zero/errors.hpp>
#include <vamp_zero/library.hpp>
#include <vamp_zero/score.hpp>


namespace {

constexpr auto application_id = std::int64_t{0x56414D50};

auto connection_config(vamp_zero::database_config const &config) -> noto::connection_config {
  auto result = noto::file_connection_config(config.path, "product_vamp");
  result.mode = noto::open_mode::READ_ONLY;
  result.busy_timeout = std::chrono::seconds{5};
  result.pragmas = {{.name = "query_only", .value = true}};
  return result;
}

auto text_value(noto::sqlite_value const &value) -> std::string {
  auto text = std::get_if<std::string>(&value.value);
  return text == nullptr ? std::string{} : *text;
}

auto close_catalog_query(noto::connection &connection, noto::statement &statement, std::expected<void, modulus::error> status) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
  auto finalized = co_await statement.async_finalize();
  if (!finalized) {
    modulus::log_error("catalog query finalization failed: " + finalized.error().describe());
    if (status) {
      status = std::unexpected(finalized.error());
    }
  }
  auto closed = co_await connection.async_close();
  if (!closed) {
    modulus::log_error("catalog connection close failed: " + closed.error().describe());
    if (status) {
      status = std::unexpected(closed.error());
    }
  }
  co_return status;
}

auto resolve_source_path(std::string const &assets_path, std::string const &source) -> std::expected<std::string, modulus::error> {
  auto fail = [] {
    return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "unsafe catalog asset path; rebuild or reinstall Product Vamp"));
  };
  auto relative = std::filesystem::path{source};
  if (source.empty() || source.find('\0') != std::string::npos || source.find('\\') != std::string::npos ||
      relative.is_absolute() || relative.extension() != ".json" ||
      std::any_of(relative.begin(), relative.end(), [](auto const &part) { return part.empty() || part == "." || part == ".."; })) {
    return fail();
  }
  auto error = std::error_code{};
  auto root = std::filesystem::weakly_canonical(assets_path, error);
  if (error) {
    return fail();
  }
  auto path = std::filesystem::weakly_canonical(root / relative, error);
  if (error) {
    return fail();
  }
  auto resolved = path.lexically_relative(root);
  if (resolved.empty() || *resolved.begin() == "..") {
    return fail();
  }
  return path.string();
}

auto count_value(noto::sqlite_value const &value) -> std::size_t {
  auto count = std::get_if<std::int64_t>(&value.value);
  return count == nullptr || *count <= 0 ? 0U : static_cast<std::size_t>(*count);
}

auto valid_title_image(noto::sqlite_value const &value) -> std::bool_t {
  auto text = text_value(value);
  return text.size() == 64U && std::all_of(text.begin(), text.end(), [](std::char_t c) { return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f'); });
}

auto compatible_catalog(noto::connection &connection) -> boost::asio::awaitable<std::bool_t> {
  auto columns = std::vector<std::string_view>{"id", "title", "composer", "key_signature", "source_path", "source_json", "measure_count", "total_pages", "title_image", "part"};
  auto parameters = std::vector<noto::sqlite_value>{noto::sqlite_value{"songs"}};
  auto selected = co_await connection.async_execute("SELECT name, type, \"notnull\", pk FROM pragma_table_info(?1) "
                                                    "WHERE EXISTS (SELECT 1 FROM pragma_table_list WHERE schema = 'main' AND name = ?1 AND type = 'table' AND strict = 1) ORDER BY cid",
                                                    std::move(parameters));
  if (!selected || selected->rows.size() != columns.size()) {
    co_return false;
  }
  for (auto index = std::size_t{}; index < columns.size(); ++index) {
    auto const &row = selected->rows[index];
    if (row.size() != 4U) {
      co_return false;
    }
    auto required = std::get_if<std::int64_t>(&row[2].value);
    auto primary = std::get_if<std::int64_t>(&row[3].value);
    auto type = index == 6U || index == 7U ? "INTEGER" : "TEXT";
    if (text_value(row[0]) != columns[index] || text_value(row[1]) != type || required == nullptr || *required != 1 || primary == nullptr || *primary != (index == 0U ? 1 : 0)) {
      co_return false;
    }
  }
  co_return true;
}

}

auto vamp_zero::async_validate_database(boost::asio::any_io_executor executor, vamp_zero::database_config config, std::bool_t integrity) -> boost::asio::awaitable<std::expected<void, modulus::error>> {
  auto error = std::error_code{};
  if (!std::filesystem::is_regular_file(config.path, error) || error) {
    co_return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "catalog is missing or unreadable: " + config.path + "; rebuild or reinstall Product Vamp"));
  }
  auto connection = noto::connection{executor, connection_config(config)};
  auto connected = co_await connection.async_connect();
  if (!connected) {
    co_return std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "cannot open catalog: " + config.path + "; rebuild or reinstall Product Vamp: " + connected.error().describe()));
  }
  auto application = co_await connection.async_application_id();
  auto status = std::expected<void, modulus::error>{};
  if (!application || *application != application_id) {
    status = std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "invalid or incompatible catalog: " + config.path + "; rebuild or reinstall Product Vamp"));
  }
  if (status && !(co_await compatible_catalog(connection))) {
    status = std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "incompatible songs catalog: " + config.path + "; rebuild or reinstall Product Vamp"));
  }
  if (status && integrity) {
    auto checked = co_await connection.async_quick_check();
    if (!checked || *checked != std::vector<std::string>{"ok"}) {
      status = std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "corrupt catalog: " + config.path + "; rebuild or reinstall Product Vamp"));
    }
  }
  auto closed = co_await connection.async_close();
  if (!status) {
    co_return std::unexpected(status.error());
  }
  co_return closed;
}

auto vamp_zero::async_load_catalog(boost::asio::any_io_executor executor, vamp_zero::database_config config, std::string assets_path)
  -> boost::asio::awaitable<std::expected<vamp_zero::catalog, modulus::error>> {
  auto connection = noto::connection{executor, connection_config(config)};
  auto connected = co_await connection.async_connect();
  if (!connected) {
    co_return std::unexpected(connected.error());
  }
  auto selected =
    co_await connection.async_prepare("SELECT id, title, composer, part, source_path, measure_count, key_signature, total_pages, title_image FROM "
                                      "songs ORDER BY title, composer, part, id");
  if (!selected) {
    auto close = co_await connection.async_close();
    if (!close) {
      modulus::log_error("database close failed after load error: " + close.error().describe());
    }
    co_return std::unexpected(selected.error());
  }
  auto parts = std::vector<vamp_zero::library_part>{};
  auto status = std::expected<void, modulus::error>{};
  for (;;) {
    auto next = co_await selected->async_step();
    if (!next) {
      status = std::unexpected(next.error());
      break;
    }
    if (!*next) {
      break;
    }
    auto const &row = **next;
    if (row.size() != 9U || count_value(row[5]) == 0U || count_value(row[7]) == 0U || !valid_title_image(row[8])) {
      status = std::unexpected(vamp_zero::make_error(vamp_zero::error_code::PERSISTENCE, "invalid performance metadata"));
      break;
    }
    auto source = resolve_source_path(assets_path, text_value(row[4]));
    if (!source) {
      status = std::unexpected(source.error());
      break;
    }
    parts.push_back({
      .id = text_value(row[0]),
      .title = text_value(row[1]),
      .composer = text_value(row[2]),
      .key_signature = text_value(row[6]),
      .part = text_value(row[3]),
      .source_path = std::move(*source),
      .measure_count = count_value(row[5]),
      .total_pages = count_value(row[7]),
      .title_image = text_value(row[8]),
    });
  }
  auto closed = co_await close_catalog_query(connection, *selected, std::move(status));
  if (!closed) {
    co_return std::unexpected(closed.error());
  }
  co_return vamp_zero::group_ordered_parts(std::move(parts));
}

auto vamp_zero::async_load_score(boost::asio::any_io_executor executor, vamp_zero::database_config config, vamp_zero::score_reference reference, std::string assets_path) -> boost::asio::awaitable<std::expected<vamp_zero::score_document, modulus::error>> {
  // Unwind inline database completions between sequential loads of many scores.
  co_await boost::asio::post(executor, boost::asio::use_awaitable);
  auto connection = noto::connection{executor, connection_config(config)};
  auto connected = co_await connection.async_connect();
  if (!connected) {
    co_return std::unexpected(connected.error());
  }
  auto selected = co_await connection.async_prepare("SELECT source_json, source_path FROM songs WHERE id = ?1");
  if (!selected) {
    static_cast<void>(co_await connection.async_close());
    co_return std::unexpected(selected.error());
  }
  auto result = std::expected<vamp_zero::score_document, modulus::error>{std::unexpected(vamp_zero::make_error(vamp_zero::error_code::NOT_FOUND, "score not found: " + reference.id))};
  auto params = std::vector<noto::sqlite_value>{noto::sqlite_value{reference.id}};
  auto bound = co_await selected->async_reset(std::move(params));
  if (!bound) {
    result = std::unexpected(bound.error());
  } else {
    auto row = co_await selected->async_step();
    if (!row) {
      result = std::unexpected(row.error());
    } else if (*row) {
      auto source = resolve_source_path(assets_path, text_value((**row)[1]));
      result = source ? vamp_zero::parse_score_document(text_value((**row)[0]), std::move(*source)) : std::expected<vamp_zero::score_document, modulus::error>{std::unexpected(source.error())};
      if (result) {
        result->id = reference.id;
      }
    }
  }
  auto status = std::expected<void, modulus::error>{};
  if (!result) {
    status = std::unexpected(result.error());
  }
  auto closed = co_await close_catalog_query(connection, *selected, std::move(status));
  if (!closed) {
    co_return std::unexpected(closed.error());
  }
  co_return result;
}