#include "dowa.h"

static void TestArena()
{
  const size_t capacity = 64;
  Dowa_PArena arena = Dowa_Arena_Create(capacity);
  assert(arena != NULL);
  assert(arena->offset == 0);
  assert(arena->capacity == capacity);

  // Allocate within capacity
  void *p1 = Dowa_Arena_Allocate(arena, 16);
  assert(p1 != NULL);
  assert(arena->offset == 16);
  sprintf((char *)p1, "%i", 10);
  assert(strcmp(p1, "10") == 0);

  // Allocate more
  void *p2 = Dowa_Arena_Allocate(arena, 32);
  assert(p2 != NULL);
  assert(arena->offset == 48);

  // Overflow allocation should return NULL and not advance offset
  void *p3 = Dowa_Arena_Allocate(arena, 20);
  assert(p3 == NULL);
  assert(arena->offset == 48);

  Dowa_Arena_Free(arena);
}

static void TestHashMap()
{
  const size_t capacity = 10;
  Dowa_PHashMap map = Dowa_HashMap_Create(capacity);
  assert(map != NULL);
  assert(map->capacity == capacity);
  assert(map->current_capacity == 0);

  // Insert "foo" -> 42
  int val1 = 42;
  Dowa_HashMap_PushValue(map, "foo", &val1, sizeof(val1));
  assert(map->current_capacity == 1);

  int idx_foo = Dowa_HashMap_GetPosition(map, "foo");
  Dowa_PHashEntry e_foo = map->entries[idx_foo];
  assert(e_foo != NULL);
  assert(strcmp(e_foo->key, "foo") == 0);
  assert(*(int*)e_foo->buffer == 42);

  // Overwrite "foo" -> 100 (capacity should not change)
  int val2 = 100;
  Dowa_HashMap_PushValue(map, "foo", &val2, sizeof(val2));
  assert(map->current_capacity == 1);

  e_foo = map->entries[idx_foo];
  assert(e_foo != NULL);
  assert(strcmp(e_foo->key, "foo") == 0);
  assert(*(int*)e_foo->buffer == 100);

  // Insert "bar" -> -7
  int val3 = -7;
  Dowa_HashMap_PushValue(map, "bar", &val3, sizeof(val3));
  assert(map->current_capacity == 2);

  int idx_bar = Dowa_HashMap_GetPosition(map, "bar");
  Dowa_PHashEntry e_bar = map->entries[idx_bar];
  assert(e_bar != NULL);
  assert(strcmp(e_bar->key, "bar") == 0);
  assert(*(int*)e_bar->buffer == -7);

  // Pop "foo"
  Dowa_HashMap_PopKey(map, "foo");
  assert(map->entries[idx_foo] == NULL);
  assert(map->current_capacity == 1);

  // Pop "bar"
  Dowa_HashMap_PopKey(map, "bar");
  assert(map->entries[idx_bar] == NULL);
  assert(map->current_capacity == 0);

  // Clean up map
  Dowa_HashMap_Free(map);
}

void Test_Dowa_HashMap_Cache_Folder()
{
  Dowa_PHashMap map = Dowa_HashMap_Create(100);

  int res = Dowa_HashMap_Cache_Folder(map, "dowa/test_folder");
  assert(res == 0 && "Folder caching should succeed");

  const char *foo_val = (const char *)Dowa_HashMap_Get(map, "foo.txt");
  assert(foo_val != NULL);
  assert(strcmp("this is foo\n", foo_val)==0);

  Dowa_HashMap_Print(map);

  Dowa_PHashMap p_bar_map = (Dowa_PHashMap)Dowa_HashMap_Get(map, "bar");
  assert(p_bar_map != NULL); 
  assert(strcmp("this is bar\n", (const char *)Dowa_HashMap_Get(p_bar_map, "bar.txt"))==0);

  Dowa_HashMap_Free(map);
}

int main(void) {
  TestArena();
  printf("Arena tests passed.\n");

  TestHashMap();
  printf("HashMap tests passed.\n");

  Test_Dowa_HashMap_Cache_Folder();
  printf("Test_Dowa_HashMap_Cache_Folder passed\n");
  return 0;
}