/**
 * Copyright (c) 2026 Dominic Masters
 *
 * This software is released under the MIT License.
 * https://opensource.org/licenses/MIT
 */

#include "dusktest.h"
#include "asset/loader/locale/assetlocaleloader.h"
#include "asset/asset.h"
#include "util/memory.h"
#include <zip.h>

// ============================================================
// Test locale file (gettext PO format)
// ============================================================

static const char_t *LOCALE_EN =
  "msgid \"\"\n"
  "msgstr \"\"\n"
  "\"Plural-Forms: nplurals=2; plural=(n != 1 ? 1 : 0);\\n\"\n"
  "\n"
  "msgid \"greeting\"\n"
  "msgstr \"Hello, World!\"\n"
  "\n"
  "msgid \"item\"\n"
  "msgid_plural \"items\"\n"
  "msgstr[0] \"one item\"\n"
  "msgstr[1] \"many items\"\n"
  "\n"
  "msgid \"score\"\n"
  "msgstr \"Score: %d\"\n"
  "\n"
  "msgid \"player\"\n"
  "msgstr \"Player: %s\"\n";

// ============================================================
// In-memory ZIP fixture (shared across all ZIP-based tests)
// ============================================================

static zip_t *g_zip = NULL;
static assetlocalefile_t g_locale;

static int locale_setup(void **state) {
  zip_error_t err;
  zip_error_init(&err);

  // Phase 1: write the zip to a growable buffer source
  zip_source_t *write_src = zip_source_buffer_create(NULL, 0, 1, &err);
  if(!write_src) return -1;

  zip_t *za = zip_open_from_source(write_src, ZIP_TRUNCATE, &err);
  if(!za) { zip_source_free(write_src); return -1; }

  size_t flen = strlen(LOCALE_EN);
  zip_source_t *fs = zip_source_buffer(za, LOCALE_EN, flen, 0);
  if(zip_file_add(za, "en.locale", fs, ZIP_FL_OVERWRITE) < 0) {
    zip_close(za); return -1;
  }

  // Keep write_src alive after zip_close so we can read the bytes back out
  zip_source_keep(write_src);
  if(zip_close(za) != 0) { zip_source_free(write_src); return -1; }

  // Phase 2: extract the raw zip bytes from the write buffer.
  // zip_source_stat must be called before zip_source_open on a written source.
  zip_stat_t zs;
  memset(&zs, 0, sizeof(zs));
  if(zip_source_stat(write_src, &zs) != 0 || !(zs.valid & ZIP_STAT_SIZE)) {
    zip_source_free(write_src); return -1;
  }

  void *zipbuf = malloc((size_t)zs.size);
  if(!zipbuf) { zip_source_free(write_src); return -1; }

  if(zip_source_open(write_src) != 0) {
    free(zipbuf); zip_source_free(write_src); return -1;
  }
  zip_source_read(write_src, zipbuf, (zip_uint64_t)zs.size);
  zip_source_close(write_src);
  zip_source_free(write_src);

  // Phase 3: open a fresh read-only archive from the extracted bytes.
  // The archive takes ownership of the source (and thus zipbuf via freep=1).
  zip_error_init(&err);
  zip_source_t *read_src = zip_source_buffer_create(
    zipbuf, (zip_uint64_t)zs.size, 1, &err
  );
  if(!read_src) { free(zipbuf); return -1; }

  g_zip = zip_open_from_source(read_src, 0, &err);
  if(!g_zip) { zip_source_free(read_src); return -1; }

  ASSET.zip = g_zip;

  // Init locale file and parse the header
  memoryZero(&g_locale, sizeof(g_locale));
  errorret_t ret = assetFileInit(&g_locale.file, "en.locale", NULL, NULL);
  if(errorIsNotOk(ret)) { errorCatch(ret); goto fail; }

  ret = assetFileOpen(&g_locale.file);
  if(errorIsNotOk(ret)) { errorCatch(ret); goto fail; }

  char_t header[512];
  ret = assetLocaleGetString(&g_locale, "", 0, header, sizeof(header));
  if(errorIsNotOk(ret)) { errorCatch(ret); assetFileClose(&g_locale.file); goto fail; }

  ret = assetLocaleParseHeader(&g_locale, header, sizeof(header));
  if(errorIsNotOk(ret)) { errorCatch(ret); assetFileClose(&g_locale.file); goto fail; }

  return 0;

fail:
  zip_close(g_zip); g_zip = NULL;
  ASSET.zip = NULL;
  return -1;
}

static int locale_teardown(void **state) {
  if(g_locale.file.zipFile != NULL) {
    errorret_t ret = assetFileClose(&g_locale.file);
    if(errorIsNotOk(ret)) errorCatch(ret);
  }

  if(g_zip != NULL) {
    zip_close(g_zip);  // also frees the read_src and zipbuf
    g_zip = NULL;
  }

  ASSET.zip = NULL;
  memoryZero(&g_locale, sizeof(g_locale));
  return 0;
}

// ============================================================
// assetLocaleParseHeader — pure tests (no ZIP required)
// ============================================================

static void test_parseHeader_english(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));

  char_t hdr[] = "Plural-Forms: nplurals=2; plural=(n != 1 ? 1 : 0);\n";
  errorret_t ret = assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_true(errorIsOk(ret));
  assert_int_equal(locale.pluralStateCount, 2);
  assert_int_equal(locale.pluralDefaultIndex, 0);
  assert_int_equal(locale.pluralOps[0], ASSET_LOCALE_PLURAL_OP_NOT_EQUAL);
  assert_int_equal(locale.pluralValues[0], 1);
  assert_int_equal(locale.pluralIndices[0], 1);

  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_parseHeader_singular(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));

  char_t hdr[] = "Plural-Forms: nplurals=1; plural=(0);\n";
  errorret_t ret = assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_true(errorIsOk(ret));
  assert_int_equal(locale.pluralStateCount, 1);
  assert_int_equal(locale.pluralDefaultIndex, 0);

  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_parseHeader_less_than(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));

  char_t hdr[] = "Plural-Forms: nplurals=2; plural=(n < 2 ? 0 : 1);\n";
  errorret_t ret = assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_true(errorIsOk(ret));
  assert_int_equal(locale.pluralStateCount, 2);
  assert_int_equal(locale.pluralOps[0], ASSET_LOCALE_PLURAL_OP_LESS);
  assert_int_equal(locale.pluralValues[0], 2);
  assert_int_equal(locale.pluralIndices[0], 0);
  assert_int_equal(locale.pluralDefaultIndex, 1);

  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_parseHeader_greater_equal(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));

  char_t hdr[] = "Plural-Forms: nplurals=2; plural=(n >= 2 ? 1 : 0);\n";
  errorret_t ret = assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_true(errorIsOk(ret));
  assert_int_equal(locale.pluralStateCount, 2);
  assert_int_equal(locale.pluralOps[0], ASSET_LOCALE_PLURAL_OP_GREATER_EQUAL);
  assert_int_equal(locale.pluralValues[0], 2);
  assert_int_equal(locale.pluralIndices[0], 1);
  assert_int_equal(locale.pluralDefaultIndex, 0);

  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_parseHeader_no_plural_forms(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));

  char_t hdr[] = "Content-Type: text/plain; charset=UTF-8\n";
  errorret_t ret = assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_true(errorIsOk(ret));
  assert_int_equal(locale.pluralStateCount, 0);

  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_parseHeader_error_nplurals_zero(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));

  char_t hdr[] = "Plural-Forms: nplurals=0; plural=(0);\n";
  errorret_t ret = assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_true(errorIsNotOk(ret));
  errorCatch(ret);
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_parseHeader_error_nplurals_too_large(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));

  char_t hdr[] = "Plural-Forms: nplurals=7; plural=(0);\n";
  errorret_t ret = assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_true(errorIsNotOk(ret));
  errorCatch(ret);
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_parseHeader_error_missing_nplurals(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));

  char_t hdr[] = "Plural-Forms: plural=(0);\n";
  errorret_t ret = assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_true(errorIsNotOk(ret));
  errorCatch(ret);
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

// ============================================================
// assetLocaleEvaluatePlural — pure tests
// ============================================================

static void test_evaluatePlural_english_singular(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));
  char_t hdr[] = "Plural-Forms: nplurals=2; plural=(n != 1 ? 1 : 0);\n";
  assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_int_equal(assetLocaleEvaluatePlural(&locale, 1), 0);
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_evaluatePlural_english_plural(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));
  char_t hdr[] = "Plural-Forms: nplurals=2; plural=(n != 1 ? 1 : 0);\n";
  assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_int_equal(assetLocaleEvaluatePlural(&locale, 0), 1);
  assert_int_equal(assetLocaleEvaluatePlural(&locale, 2), 1);
  assert_int_equal(assetLocaleEvaluatePlural(&locale, 100), 1);
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_evaluatePlural_singular_only(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));
  char_t hdr[] = "Plural-Forms: nplurals=1; plural=(0);\n";
  assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_int_equal(assetLocaleEvaluatePlural(&locale, 0), 0);
  assert_int_equal(assetLocaleEvaluatePlural(&locale, 1), 0);
  assert_int_equal(assetLocaleEvaluatePlural(&locale, 99), 0);
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_evaluatePlural_less_than_boundary(void **state) {
  assetlocalefile_t locale;
  memoryZero(&locale, sizeof(locale));
  char_t hdr[] = "Plural-Forms: nplurals=2; plural=(n < 2 ? 0 : 1);\n";
  assetLocaleParseHeader(&locale, hdr, sizeof(hdr));

  assert_int_equal(assetLocaleEvaluatePlural(&locale, 0), 0);
  assert_int_equal(assetLocaleEvaluatePlural(&locale, 1), 0);
  assert_int_equal(assetLocaleEvaluatePlural(&locale, 2), 1);
  assert_int_equal(assetLocaleEvaluatePlural(&locale, 10), 1);
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

// ============================================================
// assetLocaleGetString — ZIP-based tests
// ============================================================

static void test_getString_simple(void **state) {
  char_t result[256];
  errorret_t ret = assetLocaleGetString(&g_locale, "greeting", 0, result, sizeof(result));

  assert_true(errorIsOk(ret));
  assert_string_equal(result, "Hello, World!");
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_getString_plural_singular(void **state) {
  char_t result[256];
  errorret_t ret = assetLocaleGetString(&g_locale, "item", 1, result, sizeof(result));

  assert_true(errorIsOk(ret));
  assert_string_equal(result, "one item");
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_getString_plural_many(void **state) {
  char_t result[256];
  errorret_t ret = assetLocaleGetString(&g_locale, "item", 5, result, sizeof(result));

  assert_true(errorIsOk(ret));
  assert_string_equal(result, "many items");
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_getString_multiple_calls(void **state) {
  char_t a[256], b[256];
  errorret_t ret = assetLocaleGetString(&g_locale, "greeting", 0, a, sizeof(a));
  assert_true(errorIsOk(ret));

  // Second call rewinds the file and re-reads from scratch.
  ret = assetLocaleGetString(&g_locale, "greeting", 0, b, sizeof(b));
  assert_true(errorIsOk(ret));

  assert_string_equal(a, b);
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_getString_missing_id(void **state) {
  char_t result[256];
  errorret_t ret = assetLocaleGetString(&g_locale, "nonexistent", 0, result, sizeof(result));

  assert_true(errorIsNotOk(ret));
  errorCatch(ret);
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

// ============================================================
// assetLocaleGetStringWithArgs — ZIP-based tests
// ============================================================

static void test_getStringWithArgs_int(void **state) {
  assetlocalearg_t args[] = {
    { .type = ASSET_LOCALE_ARG_INT, .intValue = 42 }
  };
  char_t result[256];
  errorret_t ret = assetLocaleGetStringWithArgs(
    &g_locale, "score", 0, result, sizeof(result), args, 1
  );

  assert_true(errorIsOk(ret));
  assert_string_equal(result, "Score: 42");
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

static void test_getStringWithArgs_string(void **state) {
  assetlocalearg_t args[] = {
    { .type = ASSET_LOCALE_ARG_STRING, .stringValue = "Alice" }
  };
  char_t result[256];
  errorret_t ret = assetLocaleGetStringWithArgs(
    &g_locale, "player", 0, result, sizeof(result), args, 1
  );

  assert_true(errorIsOk(ret));
  assert_string_equal(result, "Player: Alice");
  assert_int_equal(memoryGetAllocatedCount(), 0);
}

// ============================================================
// main
// ============================================================

int main(void) {
  const struct CMUnitTest tests[] = {
    // parseHeader — pure
    cmocka_unit_test(test_parseHeader_english),
    cmocka_unit_test(test_parseHeader_singular),
    cmocka_unit_test(test_parseHeader_less_than),
    cmocka_unit_test(test_parseHeader_greater_equal),
    cmocka_unit_test(test_parseHeader_no_plural_forms),
    cmocka_unit_test(test_parseHeader_error_nplurals_zero),
    cmocka_unit_test(test_parseHeader_error_nplurals_too_large),
    cmocka_unit_test(test_parseHeader_error_missing_nplurals),

    // evaluatePlural — pure
    cmocka_unit_test(test_evaluatePlural_english_singular),
    cmocka_unit_test(test_evaluatePlural_english_plural),
    cmocka_unit_test(test_evaluatePlural_singular_only),
    cmocka_unit_test(test_evaluatePlural_less_than_boundary),

    // getString — in-memory ZIP
    cmocka_unit_test_setup_teardown(test_getString_simple, locale_setup, locale_teardown),
    cmocka_unit_test_setup_teardown(test_getString_plural_singular, locale_setup, locale_teardown),
    cmocka_unit_test_setup_teardown(test_getString_plural_many, locale_setup, locale_teardown),
    cmocka_unit_test_setup_teardown(test_getString_multiple_calls, locale_setup, locale_teardown),
    cmocka_unit_test_setup_teardown(test_getString_missing_id, locale_setup, locale_teardown),

    // getStringWithArgs — in-memory ZIP
    cmocka_unit_test_setup_teardown(test_getStringWithArgs_int, locale_setup, locale_teardown),
    cmocka_unit_test_setup_teardown(test_getStringWithArgs_string, locale_setup, locale_teardown),
  };
  return cmocka_run_group_tests(tests, NULL, NULL);
}