#include <cstdio>
#include <cstring>
#include <filesystem>
#include <string>
#include <utility>
#include <unistd.h>
#include <vector>

#include <sqlite3.h>

#include <opencv2/core.hpp>
#include <opencv2/imgcodecs.hpp>

extern "C" {
#include <lardon3d/photo_quality_task.h>
#include <lardon3d/project.h>
#include <lardon3d/task_queue.h>
}

#define CHECK(condition)                                                        \
  do {                                                                          \
    if (!(condition)) {                                                          \
      std::fprintf(stderr, "CHECK failed at %s:%d: %s\n", __FILE__, __LINE__, \
                   #condition);                                                  \
      return 1;                                                                  \
    }                                                                            \
  } while (0)

extern "C" const Lardon3DTaskKindRegistry *lardon3d_task_kind_registry_production(void) {
  return nullptr;
}

static bool wait_terminal(Lardon3DTaskQueue *queue, uint64_t task_id,
                          Lardon3DTaskSnapshot *snapshot) {
  for (size_t attempt = 0; attempt < 500; ++attempt) {
    if (lardon3d_task_queue_get(queue, task_id, snapshot) &&
        (snapshot->state == TASK_COMPLETED || snapshot->state == TASK_FAILED ||
         snapshot->state == TASK_CANCELLED))
      return true;
    usleep(10000);
  }
  return false;
}

static void source(Lardon3DAcquisitionCampaignSource *value, const std::string &path,
                   Lardon3DAcquisitionSourceKind kind) {
  std::snprintf(value->path, sizeof(value->path), "%s", path.c_str());
  value->source_kind = value->metadata.source_kind = kind;
  value->metadata_result = LARDON3D_ACQUISITION_OK;
  value->metadata.policy_version = LARDON3D_ACQUISITION_PAIRING_POLICY_VERSION;
}

int main() {
  char directory_template[] = "/tmp/lardon3d-photo-quality-task-XXXXXX";
  char *directory = mkdtemp(directory_template);
  CHECK(directory != nullptr);
  const std::string root(directory);
  const std::string database_path = root + "/project.lardon3d";
  const std::string jpeg_path = root + "/1-pair.jpg";
  CHECK(std::filesystem::create_directories(root + "/.lardon3d/checkpoints"));
  cv::Mat image(128, 128, CV_8UC1);
  for (int y = 0; y < image.rows; ++y)
    for (int x = 0; x < image.cols; ++x)
      image.at<unsigned char>(y, x) = ((x / 8) + (y / 8)) % 2 ? 220 : 30;
  CHECK(cv::imwrite(jpeg_path, image));

  char error[LARDON3D_PROJECT_DB_ERROR_CAPACITY]{};
  Lardon3DProjectDb *database = nullptr;
  CHECK(lardon3d_project_db_open(database_path.c_str(), &database, error) ==
        LARDON3D_PROJECT_DB_OK);
  Lardon3DProjectDbScanSet scanset{};
  CHECK(lardon3d_project_db_create_scanset(database, "quality", &scanset) ==
        LARDON3D_PROJECT_DB_OK);
  Lardon3DAppState state{};
  lardon3d_app_state_init(&state);
  state.project_loaded = true;
  state.project_db = database;
  std::snprintf(state.project_path, sizeof(state.project_path), "%s", root.c_str());
  state.hardware_profile.logical_cpu_count = 8;
  state.hardware_profile.page_size_bytes = 4096;
  state.hardware_profile.memory_total_bytes = UINT64_C(8) << 30;
  std::snprintf(state.hardware_profile.cpu_architecture,
                sizeof(state.hardware_profile.cpu_architecture), "test");
  Lardon3DResourcePolicy policy{};
  policy.maximum_cpu_load_ratio = 1.0;
  policy.maximum_io_pressure_avg10 = 100.0;
  policy.io_slot_capacity = 2;
  state.resource_governor =
      lardon3d_resource_governor_create(&state.hardware_profile, &policy);
  state.task_queue = state.resource_governor
                         ? lardon3d_task_queue_create(state.resource_governor, 4)
                         : nullptr;
  CHECK(state.task_queue != nullptr);

  Lardon3DAcquisitionCampaignSource sources[3]{};
  source(&sources[0], root + "/0-pair.arw", LARDON3D_ACQUISITION_SOURCE_RAW);
  source(&sources[1], jpeg_path, LARDON3D_ACQUISITION_SOURCE_JPEG);
  source(&sources[2], root + "/2-only.arw", LARDON3D_ACQUISITION_SOURCE_RAW);
  Lardon3DAcquisitionCampaignConfirmation pair{};
  pair.source_count = 2;
  pair.source_indices[0] = 0;
  pair.source_indices[1] = 1;
  Lardon3DPhotoQualityTaskRequest request{sources, 3, &pair, 1};
  Lardon3DAcquisitionCampaignPlan planned{};
  CHECK(lardon3d_acquisition_campaign_plan(sources, 3, &pair, 1, &planned) ==
            LARDON3D_ACQUISITION_CAMPAIGN_OK &&
        planned.group_count == 2);
  size_t request_probe_size = 0;
  CHECK(lardon3d_photo_quality_request_encode(&request, nullptr, 0, &request_probe_size));

  uint64_t task_id = 0;
  CHECK(lardon3d_project_enqueue_photo_quality(&state, scanset.scanset_id, &request, &task_id));
  Lardon3DTaskSnapshot terminal{};
  CHECK(wait_terminal(state.task_queue, task_id, &terminal));
  CHECK(terminal.state == TASK_COMPLETED && terminal.progress == 100);
  Lardon3DProjectDbPhotoQualityResult paired{}, raw_only{};
  CHECK(lardon3d_project_db_load_photo_quality_result(database, task_id, 1, &paired) ==
        LARDON3D_PROJECT_DB_OK);
  CHECK(paired.proxy_source_index == 1 &&
        paired.metrics.status == LARDON3D_PHOTO_QUALITY_METRIC_OK);
  CHECK(paired.group_id == planned.groups[0].group_id);
  CHECK(lardon3d_project_db_load_photo_quality_result(database, task_id, 2, &raw_only) ==
        LARDON3D_PROJECT_DB_OK);
  CHECK(raw_only.proxy_source_index == UINT32_MAX &&
        raw_only.metrics.status == LARDON3D_PHOTO_QUALITY_METRIC_UNAVAILABLE &&
        std::strstr(raw_only.metrics.reasons, "REQUIRES_JPEG_PROXY") != nullptr);
  Lardon3DProjectDbTask completed_generic{};
  CHECK(lardon3d_project_db_load_task(database, task_id, &completed_generic) ==
            LARDON3D_PROJECT_DB_OK &&
        completed_generic.sequence_count == 1);
  std::vector<unsigned char> corrupt_request(LARDON3D_PHOTO_QUALITY_TASK_REQUEST_MAX_BYTES);
  Lardon3DProjectDbPhotoQualityTask completed_parameters{};
  CHECK(lardon3d_project_db_load_photo_quality_task(database, task_id, corrupt_request.data(),
            corrupt_request.size(), &completed_parameters) == LARDON3D_PROJECT_DB_OK);
  CHECK(completed_parameters.group_count == 2 && completed_parameters.next_group_id == 3);
  CHECK(lardon3d_resource_governor_reservation_count(state.resource_governor) == 0);

  /* Corrupt values above the v21 operational group bound must be rejected
   * while still 64-bit SQLite integers, before narrowing into public fields. */
  sqlite3 *corruptor = nullptr;
  CHECK(sqlite3_open(database_path.c_str(), &corruptor) == SQLITE_OK);
  CHECK(sqlite3_exec(corruptor, "PRAGMA ignore_check_constraints=ON", nullptr, nullptr,
                     nullptr) == SQLITE_OK);
  const auto execute_corruption = [&](const std::string &assignment) {
    const std::string sql = "UPDATE photo_quality_triage_tasks SET " + assignment +
                            " WHERE task_id=" + std::to_string(task_id);
    return sqlite3_exec(corruptor, sql.c_str(), nullptr, nullptr, nullptr) == SQLITE_OK;
  };
  Lardon3DProjectDbPhotoQualityTask corrupt_parameters{};
  for (const char *assignment : {"group_count=-1", "group_count=5000", "group_count=4294967296",
                                 "next_group_id=0", "next_group_id=4", "next_group_id=1e20",
                                 "scanset_id=-1"}) {
    CHECK(execute_corruption(assignment));
    CHECK(lardon3d_project_db_load_photo_quality_task(database, task_id, corrupt_request.data(),
              corrupt_request.size(), &corrupt_parameters) == LARDON3D_PROJECT_DB_CORRUPT);
    CHECK(execute_corruption("scanset_id=" + std::to_string(scanset.scanset_id) +
                             ",group_count=2,next_group_id=3"));
  }

  const auto execute_result_corruption = [&](const std::string &assignment) {
    const std::string sql = "UPDATE photo_quality_triage_results SET " + assignment +
                            " WHERE task_id=" + std::to_string(task_id) + " AND group_id=1";
    return sqlite3_exec(corruptor, sql.c_str(), nullptr, nullptr, nullptr) == SQLITE_OK;
  };
  for (const auto &values : std::vector<std::pair<std::string, std::string>>{
           {"proxy_source_index=-1", "proxy_source_index=1"},
           {"proxy_source_index=4294967296", "proxy_source_index=1"},
           {"proxy_source_index=1e20", "proxy_source_index=1"},
           {"metrics_version=-1", "metrics_version=1"},
           {"metric_status=-1", "metric_status=0"},
           {"recommendation=4", "recommendation=1"},
           {"human_override=3", "human_override=0"},
           {"decoded_width=-1", "decoded_width=128"},
           {"analysis_width=4294967296", "analysis_width=128"},
           {"analysis_height=0", "analysis_height=128"},
           {"sharpness_normalized=-1.0",
            "sharpness_normalized=" + std::to_string(paired.metrics.sharpness_normalized)},
           {"clipped_white_fraction=2.0",
            "clipped_white_fraction=" + std::to_string(paired.metrics.clipped_white_fraction)}}) {
    CHECK(execute_result_corruption(values.first));
    Lardon3DProjectDbPhotoQualityResult corrupt_result{};
    CHECK(lardon3d_project_db_load_photo_quality_result(database, task_id, 1, &corrupt_result) ==
          LARDON3D_PROJECT_DB_CORRUPT);
    CHECK(execute_result_corruption(values.second));
  }
  /* Result identity must belong to the typed plan and precede its durable
   * cursor; otherwise publication would expose uncompleted plan state. */
  CHECK(execute_result_corruption("group_id=3"));
  Lardon3DProjectDbPhotoQualityResult corrupt_plan_result{};
  CHECK(lardon3d_project_db_load_photo_quality_result(database, task_id, 3,
            &corrupt_plan_result) == LARDON3D_PROJECT_DB_CORRUPT);
  CHECK(sqlite3_exec(corruptor,
      ("UPDATE photo_quality_triage_results SET group_id=1 WHERE task_id=" +
       std::to_string(task_id) + " AND group_id=3").c_str(), nullptr, nullptr, nullptr) ==
        SQLITE_OK);
  CHECK(execute_corruption("next_group_id=1"));
  CHECK(lardon3d_project_db_load_photo_quality_result(database, task_id, 1,
            &corrupt_plan_result) == LARDON3D_PROJECT_DB_CORRUPT);
  CHECK(execute_corruption("next_group_id=3"));
  sqlite3_close(corruptor);

  uint64_t cancelled_id = 0;
  Lardon3DTask *cancelled = lardon3d_project_create_photo_quality_task(
      &state, scanset.scanset_id, &request, &cancelled_id);
  CHECK(cancelled != nullptr);
  Lardon3DResourceEstimate quality_estimate{};
  CHECK(lardon3d_task_resource_estimate(cancelled, &quality_estimate));
  /* Admission includes the retained durable context in addition to the
   * documented 20 MiB one-group analyzer working set. */
  CHECK(quality_estimate.memory_fixed_bytes > UINT64_C(20) * 1024u * 1024u);
  CHECK(quality_estimate.memory_bytes_per_item == 0);
  lardon3d_task_request_cancel(cancelled);
  CHECK(lardon3d_task_queue_add(state.task_queue, cancelled, nullptr));
  CHECK(wait_terminal(state.task_queue, cancelled_id, &terminal));
  CHECK(terminal.state == TASK_CANCELLED);
  Lardon3DProjectDbPhotoQualityResult absent{};
  CHECK(raw_only.group_id == planned.groups[1].group_id);
  CHECK(lardon3d_project_db_load_photo_quality_result(database, cancelled_id, 1, &absent) ==
        LARDON3D_PROJECT_DB_NOT_FOUND);

  /* Seed the documented crash shape: plan group 1 and next group ID 2 are durable while
   * generic progress still lags. Registry recovery must begin at plan group 2 and
   * must neither re-analyze nor replace the already published pair result. */
  size_t encoded_size = 0;
  CHECK(lardon3d_photo_quality_request_encode(&request, nullptr, 0, &encoded_size));
  std::vector<unsigned char> encoded(encoded_size);
  CHECK(lardon3d_photo_quality_request_encode(&request, encoded.data(), encoded.size(),
                                               &encoded_size));
  uint64_t restart_id = 0;
  CHECK(lardon3d_project_db_allocate_task_id(database, &restart_id) == LARDON3D_PROJECT_DB_OK);
  Lardon3DTaskDurableSnapshot durable{};
  durable.id = restart_id;
  std::snprintf(durable.name, sizeof(durable.name), "quality restart");
  durable.saved_state = durable.recovery_state = TASK_PENDING;
  Lardon3DProjectDbPhotoQualityTask parameters{restart_id, scanset.scanset_id, 1, 2,
                                                encoded.data(), encoded.size()};
  CHECK(lardon3d_project_db_record_photo_quality_task(
            database, &durable, LARDON3D_PHOTO_QUALITY_TASK_KIND,
            LARDON3D_PHOTO_QUALITY_TASK_KIND_VERSION, nullptr, &parameters, 1) ==
        LARDON3D_PROJECT_DB_OK);
  Lardon3DProjectDbPhotoQualityResult sentinel = paired;
  sentinel.task_id = restart_id;
  sentinel.metrics.sharpness_raw = 12345.0;
  CHECK(lardon3d_project_db_record_photo_quality_result(database, &sentinel, 2) ==
        LARDON3D_PROJECT_DB_OK);
  /* Exact replay after the atomic cursor advance converges without replacing
   * identity or creating another result row. */
  CHECK(lardon3d_project_db_record_photo_quality_result(database, &sentinel, 2) ==
        LARDON3D_PROJECT_DB_OK);
  sqlite3 *replay_reader = nullptr;
  CHECK(sqlite3_open(database_path.c_str(), &replay_reader) == SQLITE_OK);
  sqlite3_stmt *count_statement = nullptr;
  CHECK(sqlite3_prepare_v2(replay_reader,
      "SELECT COUNT(*) FROM photo_quality_triage_results WHERE task_id=?1 AND group_id=1",
      -1, &count_statement, nullptr) == SQLITE_OK);
  CHECK(sqlite3_bind_int64(count_statement, 1, (sqlite3_int64)restart_id) == SQLITE_OK);
  CHECK(sqlite3_step(count_statement) == SQLITE_ROW &&
        sqlite3_column_int64(count_statement, 0) == 1);
  sqlite3_finalize(count_statement);
  Lardon3DProjectDbPhotoQualityResult conflicting = sentinel;
  conflicting.metrics.sharpness_raw += 1.0;
  CHECK(lardon3d_project_db_record_photo_quality_result(database, &conflicting, 2) ==
        LARDON3D_PROJECT_DB_CONSTRAINT);
  CHECK(sqlite3_exec(replay_reader,
      ("UPDATE photo_quality_triage_tasks SET next_group_id=3 WHERE task_id=" +
       std::to_string(restart_id)).c_str(), nullptr, nullptr, nullptr) == SQLITE_OK);
  CHECK(lardon3d_project_db_record_photo_quality_result(database, &sentinel, 2) ==
        LARDON3D_PROJECT_DB_CONSTRAINT);
  CHECK(sqlite3_exec(replay_reader,
      ("UPDATE photo_quality_triage_tasks SET next_group_id=2 WHERE task_id=" +
       std::to_string(restart_id)).c_str(), nullptr, nullptr, nullptr) == SQLITE_OK);
  sqlite3_close(replay_reader);
  Lardon3DProjectDbPhotoQualityResult replay_retained{};
  CHECK(lardon3d_project_db_load_photo_quality_result(database, restart_id, 1,
            &replay_retained) == LARDON3D_PROJECT_DB_OK &&
        replay_retained.metrics.sharpness_raw == sentinel.metrics.sharpness_raw);
  Lardon3DProjectDbTask generic{};
  CHECK(lardon3d_project_db_load_task(database, restart_id, &generic) == LARDON3D_PROJECT_DB_OK);
  Lardon3DTaskDurableSnapshot restart_snapshot{};
  restart_snapshot.id = generic.task_id;
  std::memcpy(restart_snapshot.name, generic.name, sizeof(restart_snapshot.name));
  restart_snapshot.progress = generic.progress;
  restart_snapshot.saved_state = generic.saved_state;
  restart_snapshot.recovery_state = generic.recovery_state;
  restart_snapshot.started_at = generic.started_at;
  restart_snapshot.finished_at = generic.finished_at;
  restart_snapshot.sequence_count = generic.sequence_count;
  restart_snapshot.estimate = quality_estimate;
  Lardon3DTaskReconstructionContext reconstruction{root.c_str(), database,
                                                    state.resource_governor, nullptr};
  const Lardon3DTaskKindDescriptor quality_descriptor = {
      LARDON3D_PHOTO_QUALITY_TASK_KIND, LARDON3D_PHOTO_QUALITY_TASK_KIND_VERSION,
      lardon3d_photo_quality_task_reconstruct};
  Lardon3DTaskKindRegistry quality_registry{};
  CHECK(lardon3d_task_kind_registry_init(&quality_registry, &quality_descriptor, 1));
  const Lardon3DTaskKindRegistry *registry = &quality_registry;
  const Lardon3DTaskKindDescriptor *descriptor = nullptr;
  CHECK(lardon3d_task_kind_registry_lookup(registry, LARDON3D_PHOTO_QUALITY_TASK_KIND,
                                           LARDON3D_PHOTO_QUALITY_TASK_KIND_VERSION,
                                           &descriptor) == LARDON3D_TASK_KIND_OK);
  Lardon3DTask *restored = nullptr;
  CHECK(lardon3d_task_kind_registry_restore(registry, LARDON3D_PHOTO_QUALITY_TASK_KIND,
                                            LARDON3D_PHOTO_QUALITY_TASK_KIND_VERSION,
                                            &restart_snapshot, &reconstruction, &restored) ==
            LARDON3D_TASK_KIND_OK &&
        restored != nullptr);
  CHECK(lardon3d_task_queue_add(state.task_queue, restored, nullptr));
  CHECK(wait_terminal(state.task_queue, restart_id, &terminal));
  CHECK(terminal.state == TASK_COMPLETED);
  Lardon3DProjectDbPhotoQualityResult retained{}, resumed_raw{};
  CHECK(lardon3d_project_db_load_photo_quality_result(database, restart_id, 1, &retained) ==
        LARDON3D_PROJECT_DB_OK && retained.metrics.sharpness_raw == 12345.0);
  CHECK(lardon3d_project_db_load_photo_quality_result(database, restart_id, 2, &resumed_raw) ==
        LARDON3D_PROJECT_DB_OK &&
        resumed_raw.metrics.status == LARDON3D_PHOTO_QUALITY_METRIC_UNAVAILABLE);

  lardon3d_task_queue_destroy(state.task_queue);
  lardon3d_resource_governor_destroy(state.resource_governor);
  lardon3d_project_db_close(database);
  std::filesystem::remove_all(root);
  return 0;
}