#include "amduat/hash/asl1.h"

#include "sha256.h"

static amduat_hash_asl1_desc_t g_hash_asl1_descs[] = {
    {0x0000, NULL, 0, {NULL, NULL}},
    {AMDUAT_HASH_ASL1_ID_SHA256,
     "HASH-ASL1-256",
     32,
     {amduat_hash_asl1_sha256_digest, NULL}},
    {0x0002, "HASH-ASL1-512", 64, {NULL, NULL}},
    {0x8001, "HASH-ASL1-PQ1", 0, {NULL, NULL}}};

#ifdef AMDUAT_HASH_ASL1_ENABLE_SHA256_STUB
static bool amduat_hash_asl1_sha256_stub(void *ctx,
                                         amduat_octets_t input,
                                         uint8_t *out,
                                         size_t out_len) {
  size_t i;

  (void)ctx;
  (void)input;

  if (out == NULL || out_len < 32) {
    return false;
  }

  for (i = 0; i < 32; ++i) {
    out[i] = 0;
  }

  return true;
}
#endif

amduat_octets_t amduat_hash_asl1_key(amduat_hash_id_t hash_id, uint8_t out[2]) {
  out[0] = (uint8_t)(hash_id >> 8);
  out[1] = (uint8_t)(hash_id & 0xff);
  return amduat_octets(out, 2);
}

const amduat_hash_asl1_desc_t *amduat_hash_asl1_desc_lookup(
    amduat_hash_id_t hash_id) {
  size_t i;

  for (i = 0; i < sizeof(g_hash_asl1_descs) / sizeof(g_hash_asl1_descs[0]);
       ++i) {
    if (g_hash_asl1_descs[i].hash_id == hash_id) {
      return &g_hash_asl1_descs[i];
    }
  }

  return NULL;
}

const amduat_hash_asl1_desc_t *amduat_hash_asl1_descs(size_t *out_len) {
  if (out_len != NULL) {
    *out_len = sizeof(g_hash_asl1_descs) / sizeof(g_hash_asl1_descs[0]);
  }
  return g_hash_asl1_descs;
}

bool amduat_hash_asl1_register_impl(amduat_hash_id_t hash_id,
                                    amduat_hash_asl1_impl_t impl) {
  size_t i;

  for (i = 0; i < sizeof(g_hash_asl1_descs) / sizeof(g_hash_asl1_descs[0]);
       ++i) {
    if (g_hash_asl1_descs[i].hash_id == hash_id) {
      g_hash_asl1_descs[i].impl = impl;
      return true;
    }
  }

  return false;
}

bool amduat_hash_asl1_digest(amduat_hash_id_t hash_id,
                             amduat_octets_t input,
                             uint8_t *out,
                             size_t out_len) {
  const amduat_hash_asl1_desc_t *desc;

  if (out == NULL) {
    return false;
  }

  desc = amduat_hash_asl1_desc_lookup(hash_id);
  if (desc == NULL || desc->digest_len == 0) {
    return false;
  }
  if (out_len < desc->digest_len) {
    return false;
  }
  if (desc->impl.digest == NULL) {
    return false;
  }

  return desc->impl.digest(desc->impl.ctx, input, out, desc->digest_len);
}

bool amduat_hash_asl1_register_sha256_stub(void) {
#ifdef AMDUAT_HASH_ASL1_ENABLE_SHA256_STUB
  amduat_hash_asl1_impl_t impl;

  impl.digest = amduat_hash_asl1_sha256_stub;
  impl.ctx = NULL;
  return amduat_hash_asl1_register_impl(AMDUAT_HASH_ASL1_ID_SHA256, impl);
#else
  return false;
#endif
}