#include "amduatd_space.h"

#include <stdbool.h>
#include <stdio.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++;
  }
}

static void expect_space_id(const amduatd_space_t *sp,
                            const char *expected,
                            const char *msg) {
  if (expected == NULL) {
    expect(sp == NULL || sp->space_id.data == NULL, msg);
    return;
  }
  expect(sp != NULL && sp->space_id.data != NULL &&
           strcmp((const char *)sp->space_id.data, expected) == 0,
         msg);
}

int main(void) {
  amduatd_space_t default_space;
  amduatd_space_t resolved_space;
  const amduatd_space_t *effective = NULL;
  amduatd_space_resolve_status_t st;

  if (!amduatd_space_init(&default_space, "alpha", false)) {
    fprintf(stderr, "FAIL: default space init\n");
    return 1;
  }

  st = amduatd_space_resolve_effective(&default_space,
                                       NULL,
                                       &resolved_space,
                                       &effective);
  expect(st == AMDUATD_SPACE_RESOLVE_OK, "resolve default without header");
  expect(effective == &default_space, "uses default space");
  expect(effective != NULL && effective->enabled, "default enabled");
  expect_space_id(effective, "alpha", "default id");

  st = amduatd_space_resolve_effective(&default_space,
                                       "beta",
                                       &resolved_space,
                                       &effective);
  expect(st == AMDUATD_SPACE_RESOLVE_OK, "resolve header override");
  expect(effective == &resolved_space, "header overrides default");
  expect(effective != NULL && effective->enabled, "header enabled");
  expect_space_id(effective, "beta", "header id");

  st = amduatd_space_resolve_effective(&default_space,
                                       "",
                                       &resolved_space,
                                       &effective);
  expect(st == AMDUATD_SPACE_RESOLVE_ERR_INVALID, "reject empty header");

  st = amduatd_space_resolve_effective(&default_space,
                                       "bad/space",
                                       &resolved_space,
                                       &effective);
  expect(st == AMDUATD_SPACE_RESOLVE_ERR_INVALID, "reject invalid header");

  if (!amduatd_space_init(&default_space, NULL, false)) {
    fprintf(stderr, "FAIL: unscoped default init\n");
    return 1;
  }
  st = amduatd_space_resolve_effective(&default_space,
                                       NULL,
                                       &resolved_space,
                                       &effective);
  expect(st == AMDUATD_SPACE_RESOLVE_OK, "resolve unscoped default");
  expect(effective == &default_space, "unscoped uses default");
  expect(effective != NULL && !effective->enabled, "unscoped disabled");
  expect_space_id(effective, NULL, "unscoped id");

  return failures == 0 ? 0 : 1;
}