#include "amduatd_fed.h"

#include "amduat/asl/ref_text.h"
#include "amduat/hash/asl1.h"

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

static int failures = 0;

static void expect(bool cond, const char *msg) {
  if (!cond) {
    fprintf(stderr, "FAIL: %s\n", msg);
    failures++;
  }
}

int main(void) {
  amduatd_fed_cfg_t cfg;
  amduatd_space_t space;
  amduat_octets_t scoped = amduat_octets(NULL, 0u);
  uint8_t digest_bytes[32];
  amduat_octets_t digest;
  amduat_reference_t ref;
  char *ref_hex = NULL;
  const char *err = NULL;
  int i;

  memset(digest_bytes, 0x2a, sizeof(digest_bytes));
  if (!amduat_octets_clone(amduat_octets(digest_bytes, sizeof(digest_bytes)),
                           &digest)) {
    fprintf(stderr, "FAIL: digest clone\n");
    return 1;
  }

  ref = amduat_reference(AMDUAT_HASH_ASL1_ID_SHA256, digest);
  if (!amduat_asl_ref_encode_hex(ref, &ref_hex)) {
    fprintf(stderr, "FAIL: ref encode\n");
    amduat_reference_free(&ref);
    return 1;
  }

  amduatd_fed_cfg_init(&cfg);
  expect(!cfg.enabled, "default disabled");
  expect(cfg.transport_kind == AMDUATD_FED_TRANSPORT_STUB, "default transport");
  expect(!cfg.require_space, "default require_space");

  {
    char *argv[] = {
        "amduatd",
        "--fed-enable",
        "--fed-transport",
        "unix",
        "--fed-unix-sock",
        "amduatd.sock",
        "--fed-domain-id",
        "42",
        "--fed-registry-ref",
        ref_hex,
        "--fed-require-space",
    };
    int argc = (int)(sizeof(argv) / sizeof(argv[0]));
    for (i = 1; i < argc; ++i) {
      amduatd_fed_parse_result_t rc;
      rc = amduatd_fed_cfg_parse_arg(&cfg, argc, argv, &i, &err);
      expect(rc == AMDUATD_FED_PARSE_OK, "fed parse ok");
    }
  }

  expect(cfg.enabled, "parsed enabled");
  expect(cfg.transport_kind == AMDUATD_FED_TRANSPORT_UNIX,
         "parsed transport");
  expect(cfg.unix_socket_set, "parsed unix socket");
  expect(cfg.local_domain_id == 42u, "parsed domain id");
  expect(cfg.registry_ref_set, "parsed registry ref");
  expect(cfg.require_space, "parsed require space");

  expect(!amduatd_fed_requirements_check(AMDUATD_STORE_BACKEND_FS,
                                         &cfg,
                                         &err),
         "requirements reject fs backend");
  expect(amduatd_fed_requirements_check(AMDUATD_STORE_BACKEND_INDEX,
                                        &cfg,
                                        &err),
         "requirements accept index backend");

  if (!amduatd_space_init(&space, NULL, false)) {
    fprintf(stderr, "FAIL: space init\n");
    amduatd_fed_cfg_free(&cfg);
    amduat_reference_free(&ref);
    free(ref_hex);
    return 1;
  }
  expect(!amduatd_fed_scope_names(&cfg, &space, "fed", &scoped, &err),
         "scope requires space");
  amduat_octets_free(&scoped);

  if (!amduatd_space_init(&space, "alpha", false)) {
    fprintf(stderr, "FAIL: space init alpha\n");
    amduatd_fed_cfg_free(&cfg);
    amduat_reference_free(&ref);
    free(ref_hex);
    return 1;
  }
  expect(amduatd_fed_scope_names(&cfg, &space, "fed", &scoped, &err),
         "scope with space");
  expect(scoped.data != NULL &&
             scoped.len == strlen("space/alpha/fed") &&
             memcmp(scoped.data,
                    "space/alpha/fed",
                    scoped.len) == 0,
         "scoped name");
  amduat_octets_free(&scoped);

  amduatd_fed_cfg_free(&cfg);
  amduat_reference_free(&ref);
  free(ref_hex);
  return failures == 0 ? 0 : 1;
}