#ifndef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 200809L
#endif

#include "amduatd_derivation_index.h"

#include "amduat/asl/asl_derivation_index_fs.h"
#include "amduat/hash/asl1.h"
#include "amduat/pel/derivation_sid.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static char *amduatd_test_make_temp_dir(void) {
  char tmpl[] = "/tmp/amduatd-deriv-XXXXXX";
  char *dir = mkdtemp(tmpl);
  size_t len;
  char *copy;
  if (dir == NULL) {
    perror("mkdtemp");
    return NULL;
  }
  len = strlen(dir);
  copy = (char *)malloc(len + 1u);
  if (copy == NULL) {
    fprintf(stderr, "failed to allocate temp dir copy\n");
    return NULL;
  }
  memcpy(copy, dir, len + 1u);
  return copy;
}

static bool amduatd_test_make_ref(uint8_t seed, amduat_reference_t *out_ref) {
  uint8_t *digest;
  size_t i;

  if (out_ref == NULL) {
    return false;
  }
  digest = (uint8_t *)malloc(32u);
  if (digest == NULL) {
    return false;
  }
  for (i = 0u; i < 32u; ++i) {
    digest[i] = (uint8_t)(seed + i);
  }
  *out_ref = amduat_reference(AMDUAT_HASH_ASL1_ID_SHA256,
                              amduat_octets(digest, 32u));
  return true;
}

int main(void) {
  char *root = amduatd_test_make_temp_dir();
  amduat_asl_derivation_index_fs_t index;
  amduat_reference_t program_ref;
  amduat_reference_t input_ref;
  amduat_reference_t output_ref;
  amduat_reference_t result_ref;
  amduat_reference_t params_ref;
  amduat_reference_t input_refs[1];
  amduat_reference_t output_refs[1];
  amduat_pel_run_result_t run_result;
  amduat_asl_derivation_record_t *records = NULL;
  size_t record_count = 0u;
  amduat_asl_store_error_t err;

  if (root == NULL) {
    return 1;
  }

  if (!amduatd_test_make_ref(1u, &program_ref) ||
      !amduatd_test_make_ref(2u, &input_ref) ||
      !amduatd_test_make_ref(3u, &output_ref) ||
      !amduatd_test_make_ref(4u, &result_ref)) {
    fprintf(stderr, "failed to build refs\n");
    free(root);
    return 1;
  }

  input_refs[0] = input_ref;
  output_refs[0] = output_ref;
  memset(&params_ref, 0, sizeof(params_ref));
  memset(&run_result, 0, sizeof(run_result));
  run_result.has_result_value = true;
  run_result.result_value.core_result.status = AMDUAT_PEL_EXEC_STATUS_OK;
  run_result.result_value.has_store_failure = false;
  run_result.output_refs = output_refs;
  run_result.output_refs_len = 1u;
  run_result.result_ref = result_ref;

  err = AMDUAT_ASL_STORE_OK;
  if (!amduatd_derivation_index_pel_run(root,
                                        false,
                                        program_ref,
                                        input_refs,
                                        1u,
                                        false,
                                        params_ref,
                                        &run_result,
                                        false,
                                        params_ref,
                                        &err)) {
    fprintf(stderr, "unexpected derivation index failure when disabled\n");
    free(root);
    return 1;
  }

  if (!amduat_asl_derivation_index_fs_init(&index, root)) {
    fprintf(stderr, "failed to init derivation index\n");
    free(root);
    return 1;
  }

  err = amduat_asl_derivation_index_fs_list(&index, output_ref,
                                            &records, &record_count);
  if (err != AMDUAT_ASL_STORE_ERR_NOT_FOUND) {
    fprintf(stderr, "expected no records when disabled, got %d\n", (int)err);
    free(root);
    return 1;
  }

  err = AMDUAT_ASL_STORE_OK;
  if (!amduatd_derivation_index_pel_run(root,
                                        true,
                                        program_ref,
                                        input_refs,
                                        1u,
                                        false,
                                        params_ref,
                                        &run_result,
                                        false,
                                        params_ref,
                                        &err)) {
    fprintf(stderr, "expected derivation index to succeed\n");
    free(root);
    return 1;
  }

  err = amduat_asl_derivation_index_fs_list(&index, output_ref,
                                            &records, &record_count);
  if (err != AMDUAT_ASL_STORE_OK || record_count != 1u) {
    fprintf(stderr, "expected one derivation record, got %d count=%zu\n",
            (int)err, record_count);
    free(root);
    return 1;
  }

  {
    amduat_pel_derivation_sid_input_t sid_input;
    amduat_octets_t sid = amduat_octets(NULL, 0u);

    memset(&sid_input, 0, sizeof(sid_input));
    sid_input.program_ref = program_ref;
    sid_input.input_refs = input_refs;
    sid_input.input_refs_len = 1u;
    sid_input.has_params_ref = false;
    sid_input.has_exec_profile = false;
    sid_input.exec_profile = amduat_octets(NULL, 0u);

    if (!amduat_pel_derivation_sid_compute(&sid_input, &sid)) {
      fprintf(stderr, "failed to compute expected sid\n");
      amduat_asl_derivation_records_free(records, record_count);
      free(root);
      return 1;
    }

    if (!amduat_octets_eq(records[0].sid, sid)) {
      fprintf(stderr, "sid mismatch\n");
      amduat_octets_free(&sid);
      amduat_asl_derivation_records_free(records, record_count);
      free(root);
      return 1;
    }
    if (!amduat_reference_eq(records[0].program_ref, program_ref)) {
      fprintf(stderr, "program_ref mismatch\n");
      amduat_octets_free(&sid);
      amduat_asl_derivation_records_free(records, record_count);
      free(root);
      return 1;
    }
    if (records[0].output_index != 0u) {
      fprintf(stderr, "output_index mismatch\n");
      amduat_octets_free(&sid);
      amduat_asl_derivation_records_free(records, record_count);
      free(root);
      return 1;
    }
    amduat_octets_free(&sid);
  }

  amduat_asl_derivation_records_free(records, record_count);
  amduat_reference_free(&program_ref);
  amduat_reference_free(&input_ref);
  amduat_reference_free(&output_ref);
  amduat_reference_free(&result_ref);
  free(root);
  return 0;
}