#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include "dowa.h"
#include <time.h>

int main(void)
{
  printf("=== Testing NEW dowa API (stb_ds style) ===\n\n");

  // --- Test Arena Allocator ---
  printf("Testing Arena Allocator...\n");
  Dowa_Arena *p_arena = Dowa_Arena_Create(64);
  assert(p_arena && "Arena creation failed");

  char *p_arena_mem1 = (char *)Dowa_Arena_Allocate(p_arena, 16);
  assert(p_arena_mem1 && "Arena allocation #1 failed");
  strcpy(p_arena_mem1, "hello arena");
  printf("  [Arena Allocate] mem1 = \"%s\"\n", p_arena_mem1);

  char *p_arena_mem2 = (char *)Dowa_Arena_Allocate(p_arena, 8);
  assert(p_arena_mem2 && "Arena allocation #2 failed");
  strcpy(p_arena_mem2, "data");
  printf("  [Arena Allocate] mem2 = \"%s\"\n", p_arena_mem2);

  Dowa_Arena_Free(p_arena);
  printf("  [Arena] destroyed\n\n");

  // --- Test Array Operations ---
  printf("Testing Array Operations...\n");
  int32* p_numbers = NULL;

  Dowa_Array_Push(p_numbers, 10);
  Dowa_Array_Push(p_numbers, 20);
  Dowa_Array_Push(p_numbers, 30);
  Dowa_Array_Push(p_numbers, 40);

  printf("  Array length: %zu\n", Dowa_Array_Length(p_numbers));
  printf("  Array capacity: %zu\n", Dowa_Array_Capacity(p_numbers));
  printf("  Array contents:");
  for (size_t i = 0; i < Dowa_Array_Length(p_numbers); i++)
    printf(" %d", p_numbers[i]);
  printf("\n");

  int32 popped = Dowa_Array_Pop(p_numbers);
  printf("  Popped value: %d\n", popped);
  printf("  Array length after pop: %zu\n", Dowa_Array_Length(p_numbers));

  Dowa_Array_Clear(p_numbers);
  printf("  Array length after clear: %zu\n", Dowa_Array_Length(p_numbers));

  Dowa_Array_Free(p_numbers);
  printf("  Array freed\n\n");

  // --- Test HashMap Basic Operations (String Keys) ---
  printf("Testing HashMap with String Keys...\n");
  Dowa_KV(char*, char*)* p_map = NULL;

  Dowa_HashMap_Push(p_map, "name", "John");
  Dowa_HashMap_Push(p_map, "city", "New York");
  Dowa_HashMap_Push(p_map, "country", "USA");

  printf("  HashMap count: %zu\n", Dowa_HashMap_Count(p_map));

  void* p_kv = Dowa_HashMap_Get_Ptr(p_map, "name");
  if (p_kv)
  {
    Dowa_KV(char*, char*)* p_pair = (Dowa_KV(char*, char*)*)p_kv;
    printf("  HashMap['name']: %s\n", p_pair->value);
  }

  p_kv = Dowa_HashMap_Get_Ptr(p_map, "city");
  if (p_kv)
  {
    Dowa_KV(char*, char*)* p_pair = (Dowa_KV(char*, char*)*)p_kv;
    printf("  HashMap['city']: %s\n", p_pair->value);
  }

  boolean has_name = Dowa_HashMap_Has_Key(p_map, "name");
  printf("  Has key 'name': %d\n", has_name);

  boolean has_missing = Dowa_HashMap_Has_Key(p_map, "missing");
  printf("  Has key 'missing': %d\n", has_missing);

  printf("  Iterating over HashMap:\n");
  size_t map_length = Dowa_Array_Length(p_map);
  for (size_t i = 0; i < map_length; i++)
    printf("    [%zu] '%s' => '%s'\n", i, p_map[i].key, p_map[i].value);

  Dowa_HashMap_Delete(p_map, "city");
  printf("  After deleting 'city', count: %zu\n", Dowa_HashMap_Count(p_map));

  Dowa_HashMap_Clear(p_map);
  printf("  After clear, count: %zu\n", Dowa_HashMap_Count(p_map));

  Dowa_HashMap_Free(p_map);
  printf("  HashMap freed\n\n");

  // --- Test HashMap with Int Keys (Binary) ---
  printf("Testing HashMap with Int Keys...\n");
  Dowa_KV(int32, char*)* p_int_map = NULL;

  int32 key1 = 1;
  int32 key2 = 2;
  int32 key3 = 3;

  Dowa_HashMap_Push_Binary(p_int_map, &key1, sizeof(int32), "one");
  Dowa_HashMap_Push_Binary(p_int_map, &key2, sizeof(int32), "two");
  Dowa_HashMap_Push_Binary(p_int_map, &key3, sizeof(int32), "three");

  printf("  Int map count: %zu\n", Dowa_HashMap_Count(p_int_map));

  p_kv = Dowa_HashMap_Get_Ptr_Binary(p_int_map, &key1, sizeof(int32));
  if (p_kv)
  {
    Dowa_KV(int32, char*)* p_pair = (Dowa_KV(int32, char*)*)p_kv;
    printf("  Int map[1]: '%s'\n", p_pair->value);
  }

  p_kv = Dowa_HashMap_Get_Ptr_Binary(p_int_map, &key2, sizeof(int32));
  if (p_kv)
  {
    Dowa_KV(int32, char*)* p_pair = (Dowa_KV(int32, char*)*)p_kv;
    printf("  Int map[2]: '%s'\n", p_pair->value);
  }

  printf("  Iterating over Int HashMap:\n");
  map_length = Dowa_Array_Length(p_int_map);
  for (size_t i = 0; i < map_length; i++)
    printf("    [%zu] %d => '%s'\n", i, p_int_map[i].key, p_int_map[i].value);

  Dowa_HashMap_Free(p_int_map);
  printf("  Int map freed\n\n");

  // --- Test HashMap with Arena ---
  printf("Testing HashMap with Arena...\n");
  Dowa_Arena *p_map_arena = Dowa_Arena_Create(1024);
  Dowa_KV(char*, int32) *p_arena_map = NULL;

  Dowa_HashMap_Push_Arena(p_arena_map, "x", 100, p_map_arena);
  Dowa_HashMap_Push_Arena(p_arena_map, "y", 200, p_map_arena);
  Dowa_HashMap_Push_Arena(p_arena_map, "z", 300, p_map_arena);

  printf("  Arena map count: %zu\n", Dowa_HashMap_Count(p_arena_map));

  p_kv = Dowa_HashMap_Get_Ptr(p_arena_map, "x");
  if (p_kv)
  {
    Dowa_KV(char*, int32)* p_pair = (Dowa_KV(char*, int32)*)p_kv;
    printf("  Arena map['x']: %d\n", p_pair->value);
  }

  p_kv = Dowa_HashMap_Get_Ptr(p_arena_map, "y");
  if (p_kv)
  {
    Dowa_KV(char*, int32)* p_pair = (Dowa_KV(char*, int32)*)p_kv;
    printf("  Arena map['y']: %d\n", p_pair->value);
  }

  printf("  Iterating over Arena HashMap:\n");
  map_length = Dowa_Array_Length(p_arena_map);
  for (size_t i = 0; i < map_length; i++)
    printf("    [%zu] '%s' => %d\n", i, p_arena_map[i].key, p_arena_map[i].value);

  Dowa_Arena_Free(p_map_arena);
  printf("  Arena destroyed (including map)\n\n");

  // --- Test Array with Arena ---
  printf("Testing Array with Arena...\n");
  Dowa_Arena *p_array_arena = Dowa_Arena_Create(1024);
  int32* p_arena_numbers = NULL;

  Dowa_Array_Push_Arena(p_arena_numbers, 5, p_array_arena);
  Dowa_Array_Push_Arena(p_arena_numbers, 10, p_array_arena);
  Dowa_Array_Push_Arena(p_arena_numbers, 15, p_array_arena);

  printf("  Arena array length: %zu\n", Dowa_Array_Length(p_arena_numbers));
  printf("  Arena array contents:");
  for (size_t i = 0; i < Dowa_Array_Length(p_arena_numbers); i++)
    printf(" %d", p_arena_numbers[i]);
  printf("\n");

  Dowa_Arena_Free(p_array_arena);
  printf("  Arena destroyed (including array)\n\n");

  // --- Test Medium HashMap (Stress Test) ---
  printf("Testing Medium HashMap (Stress Test)...\n");
  Dowa_KV(char*, int32)* p_large_map = NULL;
  
  char key_buffer[32];
  for (int32 i = 0; i < 100; i++)
  {
    sprintf(key_buffer, "key_%d", i);
    Dowa_HashMap_Push(p_large_map, key_buffer, i * 10);
  }
  
  printf("  Medium map count: %zu\n", Dowa_HashMap_Count(p_large_map));
  
  sprintf(key_buffer, "key_50");
  p_kv = Dowa_HashMap_Get_Ptr(p_large_map, key_buffer);
  if (p_kv)
  {
    Dowa_KV(char*, int32)* p_pair = (Dowa_KV(char*, int32)*)p_kv;
    printf("  Medium map['key_50']: %d\n", p_pair->value);
  }
  
  sprintf(key_buffer, "key_99");
  boolean has_99 = Dowa_HashMap_Has_Key(p_large_map, key_buffer);
  printf("  Has key 'key_99': %d\n", has_99);
  
  Dowa_HashMap_Free(p_large_map);
  printf("  Medium map freed\n\n");

  // --- Test Key Storage Integrity ---
  printf("Testing Key Storage Integrity (Regression Test)...\n");
  Dowa_KV(char*, char*)* p_integrity_map = NULL;

  // Simple test first
  Dowa_HashMap_Push(p_integrity_map, "HTTP_Method", "GET");
  Dowa_HashMap_Push(p_integrity_map, "Path", "/index.html");

  printf("  Testing simple 2-key map...\n");
  void* p_method = Dowa_HashMap_Get_Ptr(p_integrity_map, "HTTP_Method");
  void* p_path = Dowa_HashMap_Get_Ptr(p_integrity_map, "Path");

  if (p_method && p_path)
  {
    Dowa_KV(char*, char*)* p_m = (Dowa_KV(char*, char*)*)p_method;
    Dowa_KV(char*, char*)* p_p = (Dowa_KV(char*, char*)*)p_path;
    printf("    Method: key='%s', value='%s'\n", p_m->key, p_m->value);
    printf("    Path: key='%s', value='%s'\n", p_p->key, p_p->value);
    printf("  PASS: Simple test passed\n");
  }
  else
  {
    printf("    FAIL: Could not find keys\n");
  }

  Dowa_HashMap_Free(p_integrity_map);
  p_integrity_map = NULL;

  // Test with arena allocator
  printf("  Testing arena-allocated map...\n");
  Dowa_Arena *p_integrity_arena = Dowa_Arena_Create(4096);
  Dowa_HashMap_Push_Arena(p_integrity_map, "HTTP_Method", "POST", p_integrity_arena);
  Dowa_HashMap_Push_Arena(p_integrity_map, "Content-Type", "application/json", p_integrity_arena);

  p_method = Dowa_HashMap_Get_Ptr(p_integrity_map, "HTTP_Method");
  void* p_content_type = Dowa_HashMap_Get_Ptr(p_integrity_map, "Content-Type");

  if (p_method && p_content_type)
  {
    Dowa_KV(char*, char*)* p_m = (Dowa_KV(char*, char*)*)p_method;
    Dowa_KV(char*, char*)* p_ct = (Dowa_KV(char*, char*)*)p_content_type;
    printf("    Method: key='%s', value='%s'\n", p_m->key, p_m->value);
    printf("    Content-Type: key='%s', value='%s'\n", p_ct->key, p_ct->value);
    printf("  PASS: Arena test passed\n");
  }
  else
  {
    printf("    FAIL: Could not find keys\n");
  }

  Dowa_Arena_Free(p_integrity_arena);
  printf("  Key integrity test complete\n\n");

  printf("=== String Manipulations === \n\n");

  printf("  Split strings without arena \n\n");
  {
    char *from = "june_park_hell";
    char *token = "_";
    Dowa_Arena *p_arena = NULL;
  
    char **arr = Dowa_String_Split(from, token, strlen(from), 1, p_arena);
    int32 arr_length = Dowa_Array_Length(arr);
    printf("arr_length: %i\n", arr_length);
    for (int32 i = 0; i < arr_length; i++)
      printf("%s\n", arr[i]);
    Dowa_Array_Free(arr);
    if (arr == NULL)
      printf("Free properly\n");
  }

  printf("\n  Split strings with arena \n\n");
  {
    char *from = "june_park_hell_arena";
    char *token = "_";
    Dowa_Arena *p_arena = Dowa_Arena_Create(1024);

    char **arr = Dowa_String_Split(from, token, strlen(from), 1, p_arena);
    int32 arr_length = Dowa_Array_Length(arr);
    for (int32 i = 0; i < arr_length; i++)
      printf("%s\n", arr[i]);
    Dowa_Arena_Free(p_arena);
  }

  printf("\n  Arena Copy string\n\n");
  {
    char *from = "copy_this";
    Dowa_Arena *p_arena = Dowa_Arena_Create(1024);

    char *value = Dowa_String_Copy_Arena(from, p_arena);
    assert(strcmp(value, from) == 0);
    assert(value[9] == '\0');

    Dowa_Arena_Free(p_arena);
  }


  printf("\n  UUID\n\n");
  {
    char *uuid = Dowa_String_UUID((uint32)time(NULL), NULL);
    printf("UUID %s\n", uuid);
  }

  {
    Dowa_Arena *json_arena = Dowa_Arena_Create(1024);
    char raw[] = {'"', '\\', '\n', '\t', 0x01, 'x', '\0'};
    char *escaped = Dowa_JSON_Escape_String(raw, 6, json_arena);
    assert(escaped);
    assert(strcmp(escaped, "\\\"\\\\\\n\\t\\u0001x") == 0);
    Dowa_Arena_Free(json_arena);
  }

  {
    Dowa_Arena *json_arena = Dowa_Arena_Create(1024);
    const char *source = "{\"message\":\"say \\\"hello\\\"\\\\now\"}";
    Dowa_JSON_Value parsed = Dowa_JSON_Parse(
        source, (int32)strlen(source), json_arena);
    assert(parsed.type == DOWA_JSON_OBJECT);
    char *message = Dowa_JSON_Get_String(parsed.object_val, "message");
    assert(message);
    assert(strcmp(message, "say \"hello\"\\now") == 0);
    Dowa_Arena_Free(json_arena);
  }

  printf("=== Math/Random === \n\n");

  printf("\n  RandomNumberGenerator\n\n");
  {
    uint32 seed_number = 32;
    uint32 random_number = Dowa_Math_Random_Uint32(seed_number);
    uint32 random_number2 = Dowa_Math_Random_Uint32(random_number);
    printf("randon_number 1: %i\n", random_number);
    printf("randon_number 2: %i\n", random_number2);
  }

  /* --- Malformed JSON regression tests --- */
  {
    Dowa_Arena *a = Dowa_Arena_Create(1024);
    const char *s = "{\"username\":[x]}";
    Dowa_JSON_Value v = Dowa_JSON_Parse(s, (int32)strlen(s), a);
    assert(v.type == DOWA_JSON_OBJECT);
    Dowa_JSON_Value *uv = Dowa_JSON_Get(v.object_val, "username");
    assert(uv && uv->type == DOWA_JSON_ARRAY);
    Dowa_Arena_Free(a);
  }
  {
    Dowa_Arena *a = Dowa_Arena_Create(1024);
    const char *s = "xyz";
    Dowa_JSON_Value v = Dowa_JSON_Parse(s, (int32)strlen(s), a);
    assert(v.type == DOWA_JSON_NULL);
    Dowa_Arena_Free(a);
  }
  {
    Dowa_Arena *a = Dowa_Arena_Create(1024);
    const char *s = "[x, y, z]";
    Dowa_JSON_Value v = Dowa_JSON_Parse(s, (int32)strlen(s), a);
    assert(v.type == DOWA_JSON_ARRAY);
    Dowa_Arena_Free(a);
  }
  {
    Dowa_Arena *a = Dowa_Arena_Create(1024);
    const char *s = "{\"a\":x,\"b\":\"ok\"}";
    Dowa_JSON_Value v = Dowa_JSON_Parse(s, (int32)strlen(s), a);
    assert(v.type == DOWA_JSON_OBJECT);
    char *b = Dowa_JSON_Get_String(v.object_val, "b");
    assert(b && strcmp(b, "ok") == 0);
    Dowa_Arena_Free(a);
  }
  {
    Dowa_Arena *a = Dowa_Arena_Create(1024);
    const char *s = "{\"a\":\"unclosed";
    Dowa_JSON_Value v = Dowa_JSON_Parse(s, (int32)strlen(s), a);
    assert(v.type == DOWA_JSON_OBJECT);
    Dowa_Arena_Free(a);
  }

  printf("=== All tests passed! ===\n");
  return 0;
}