#ifdef _WIN32
#include <windows.h>
#endif

#define WOTA_IMPLEMENTATION
#include "wota.h"

#define STB_DS_IMPLEMENTATION
#include "stb_ds.h"

#include "cell.h"
#include "cell_internal.h"

#define ENGINE "internal/engine.cm"
#define CELL_SHOP_DIR ".cell"
#define CELL_CORE_DIR "packages/core"

#include <signal.h>
#include <unistd.h>
#include <sys/stat.h>

/* Test suite declarations */
int run_c_test_suite(JSContext *ctx);
static int run_test_suite(size_t heap_size);

cell_rt *root_cell = NULL;
static char *core_path = NULL;

// Get the home directory
static const char* get_home_dir(void) {
  const char *home = getenv("HOME");
  if (!home) {
    home = getenv("USERPROFILE"); // Windows fallback
  }
  return home;
}

// Find and verify the cell shop at ~/.cell
int find_cell_shop(void)
{
  const char *home = get_home_dir();
  if (!home) {
    printf("ERROR: Could not determine home directory. Set HOME environment variable.\n");
    return 0;
  }

  // Build path to ~/.cell/core
  size_t path_len = strlen(home) + strlen("/" CELL_SHOP_DIR "/" CELL_CORE_DIR) + 1;
  core_path = malloc(path_len);
  if (!core_path) {
    printf("ERROR: Could not allocate memory for core path\n");
    return 0;
  }
  snprintf(core_path, path_len, "%s/" CELL_SHOP_DIR "/" CELL_CORE_DIR, home);

  // Check if the core directory exists
  struct stat st;
  if (stat(core_path, &st) != 0 || !S_ISDIR(st.st_mode)) {
    printf("ERROR: Cell shop not found at %s/" CELL_SHOP_DIR "\n", home);
    printf("Run 'cell install' to set up the cell environment.\n");
    free(core_path);
    core_path = NULL;
    return 0;
  }

  return 1;
}

// Load a file from the core directory
static char* load_core_file(const char *filename, size_t *out_size) {
  if (!core_path) return NULL;
  
  size_t path_len = strlen(core_path) + 1 + strlen(filename) + 1;
  char *full_path = malloc(path_len);
  if (!full_path) return NULL;
  
  snprintf(full_path, path_len, "%s/%s", core_path, filename);
  
  FILE *fh = fopen(full_path, "rb");
  free(full_path);
  
  if (!fh) return NULL;
  
  fseek(fh, 0, SEEK_END);
  long file_size = ftell(fh);
  fseek(fh, 0, SEEK_SET);
  
  char *data = malloc(file_size + 1);
  if (!data) {
    fclose(fh);
    return NULL;
  }
  
  if (fread(data, 1, file_size, fh) != (size_t)file_size) {
    free(data);
    fclose(fh);
    return NULL;
  }
  
  fclose(fh);
  data[file_size] = 0;
  
  if (out_size) *out_size = file_size;
  return data;
}

// Get the core path for use by scripts
const char* cell_get_core_path(void) {
  return core_path;
}

void actor_disrupt(cell_rt *crt)
{
  crt->disrupt = 1;
  if (crt->state != ACTOR_RUNNING)
    actor_free(crt);
}

JSValue js_os_use(JSContext *js);
JSValue js_math_use(JSContext *js);

void script_startup(cell_rt *prt)
{
  JSRuntime *rt;

  rt = JS_NewRuntime();

  JSContext *js = JS_NewContextRaw(rt);
  JS_SetInterruptHandler(rt, (JSInterruptHandler *)actor_interrupt_cb, prt);
  
  JS_AddIntrinsicBaseObjects(js);
  JS_AddIntrinsicEval(js);
  JS_AddIntrinsicRegExp(js);
  JS_AddIntrinsicJSON(js);

  JS_SetContextOpaque(js, prt);
  prt->context = js;

  cell_rt *crt = JS_GetContextOpaque(js);
  JS_FreeValue(js, js_blob_use(js));

  /* Use GC refs to protect values during allocations.
     Initialize values to JS_NULL before adding to GC list to avoid
     scanning uninitialized memory. */
  JSGCRef globalThis_ref, cell_ref, hidden_fn_ref;
  globalThis_ref.val = JS_NULL;
  cell_ref.val = JS_NULL;
  hidden_fn_ref.val = JS_NULL;
  JS_AddGCRef(js, &globalThis_ref);
  JS_AddGCRef(js, &cell_ref);
  JS_AddGCRef(js, &hidden_fn_ref);

  globalThis_ref.val = JS_GetGlobalObject(js);
  cell_ref.val = JS_NewObject(js);
  JS_SetPropertyStr(js, globalThis_ref.val, "cell", cell_ref.val);

  hidden_fn_ref.val = JS_NewObject(js);
  JS_SetPropertyStr(js, cell_ref.val, "hidden", hidden_fn_ref.val);

  /* Call functions that allocate BEFORE using their results as arguments,
     to avoid GC invalidating already-evaluated arguments. */
  JSGCRef tmp_ref;
  tmp_ref.val = JS_NULL;
  JS_AddGCRef(js, &tmp_ref);

  tmp_ref.val = js_os_use(js);
  JS_SetPropertyStr(js, hidden_fn_ref.val, "os", tmp_ref.val);

  tmp_ref.val = JS_NewObject(js);
  crt->actor_sym = tmp_ref.val;
  tmp_ref.val = JS_DupValue(js, crt->actor_sym);
  JS_SetPropertyStr(js, hidden_fn_ref.val, "actorsym", tmp_ref.val);

  if (crt->init_wota) {
    tmp_ref.val = wota2value(js, crt->init_wota);
    JS_SetPropertyStr(js, hidden_fn_ref.val, "init", tmp_ref.val);
    // init wota can now be freed
    free(crt->init_wota);
    crt->init_wota = NULL;
  }

  // Store the core path for scripts to use
  if (core_path) {
    tmp_ref.val = JS_NewString(js, core_path);
    JS_SetPropertyStr(js, hidden_fn_ref.val, "core_path", tmp_ref.val);
  }

  JS_DeleteGCRef(js, &tmp_ref);

  JS_DeleteGCRef(js, &hidden_fn_ref);
  JS_DeleteGCRef(js, &cell_ref);
  JS_DeleteGCRef(js, &globalThis_ref);

  // Load engine.cm from the core directory
  size_t engine_size;
  char *data = load_core_file(ENGINE, &engine_size);
  if (!data) {
    printf("ERROR: Could not load %s from %s!\n", ENGINE, core_path);
    return;
  }

  crt->state = ACTOR_RUNNING;
  JSValue v = JS_Eval(js, data, engine_size, ENGINE, 0);
  free(data);
  uncaught_exception(js, v);
  crt->state = ACTOR_IDLE;
  set_actor_state(crt);
}

static void signal_handler(int sig)
{
  const char *str = NULL;
#ifndef TARGET_PLAYDATE
  switch (sig) {
    case SIGABRT: str = "SIGABRT"; break;
    case SIGFPE:  str = "SIGFPE";  break;
    case SIGILL:  str = "SIGILL";  break;
    case SIGINT:  str = "SIGINT";  break;
    case SIGSEGV: str = "SIGSEGV"; break;
    case SIGTERM: str = "SIGTERM"; break;
  }
#endif
  if (!str) return;

  exit_handler();
}

/* Run the C test suite with minimal runtime setup */
static int run_test_suite(size_t heap_size)
{
  JSRuntime *rt = JS_NewRuntime();
  if (!rt) {
    printf("Failed to create JS runtime\n");
    return 1;
  }

  JSContext *ctx = JS_NewContextRawWithHeapSize(rt, heap_size);
  if (!ctx) {
    printf("Failed to create JS context\n");
    JS_FreeRuntime(rt);
    return 1;
  }

  JS_AddIntrinsicBaseObjects(ctx);

  int result = run_c_test_suite(ctx);

  JS_FreeContext(ctx);
  JS_FreeRuntime(rt);

  return result;
}

/* Run an immediate script string */
static int run_eval(const char *script_or_file, int print_bytecode)
{
  if (!find_cell_shop()) return 1;

  /* Check if argument is a file path */
  struct stat st;
  char *script = NULL;
  char *allocated_script = NULL;
  const char *filename = "<eval>";

  if (stat(script_or_file, &st) == 0 && S_ISREG(st.st_mode)) {
    /* It's a file, read its contents */
    FILE *f = fopen(script_or_file, "r");
    if (!f) {
      printf("Failed to open file: %s\n", script_or_file);
      return 1;
    }
    allocated_script = malloc(st.st_size + 1);
    if (!allocated_script) {
      fclose(f);
      printf("Failed to allocate memory for script\n");
      return 1;
    }
    size_t read_size = fread(allocated_script, 1, st.st_size, f);
    fclose(f);
    allocated_script[read_size] = '\0';
    script = allocated_script;
    filename = script_or_file;
  } else {
    /* Treat as inline script */
    script = (char *)script_or_file;
  }

  JSRuntime *rt = JS_NewRuntime();
  if (!rt) {
    printf("Failed to create JS runtime\n");
    free(allocated_script);
    return 1;
  }

  JSContext *ctx = JS_NewContextRaw(rt);
  if (!ctx) {
    printf("Failed to create JS context\n");
    JS_FreeRuntime(rt);
    free(allocated_script);
    return 1;
  }

  JS_AddIntrinsicBaseObjects(ctx);
  JS_AddIntrinsicEval(ctx);
  JS_AddIntrinsicRegExp(ctx);
  JS_AddIntrinsicJSON(ctx);

  int result = 0;

  if (print_bytecode) {
    /* Compile only, then dump and optionally execute */
    JSValue func = JS_Eval(ctx, script, strlen(script), filename, JS_EVAL_FLAG_COMPILE_ONLY);
    if (JS_IsException(func)) {
      uncaught_exception(ctx, func);
      result = 1;
    } else {
      printf("=== Compiled Bytecode ===\n");
      JS_DumpFunctionBytecode(ctx, func);

      /* Link - resolve global references */
      JSValue linked = JS_LinkFunction(ctx, func);
      if (JS_IsException(linked)) {
        uncaught_exception(ctx, linked);
        result = 1;
      } else {
        printf("\n=== Linked Bytecode ===\n");
        JS_DumpFunctionBytecode(ctx, linked);

        /* Now execute the linked bytecode */
        JSValue v = JS_EvalFunction(ctx, linked);
        if (JS_IsException(v)) {
          uncaught_exception(ctx, v);
          result = 1;
        } else {
          JS_FreeValue(ctx, v);
        }
      }
    }
  } else {
    /* Compile, link, execute */
    JSValue func = JS_Eval(ctx, script, strlen(script), filename, JS_EVAL_FLAG_COMPILE_ONLY);
    if (JS_IsException(func)) {
      uncaught_exception(ctx, func);
      result = 1;
    } else {
      JSValue linked = JS_LinkFunction(ctx, func);
      if (JS_IsException(linked)) {
        uncaught_exception(ctx, linked);
        result = 1;
      } else {
        JSValue v = JS_EvalFunction(ctx, linked);
        if (JS_IsException(v)) {
          uncaught_exception(ctx, v);
          result = 1;
        } else {
          JS_FreeValue(ctx, v);
        }
      }
    }
  }

  JS_FreeContext(ctx);
  JS_FreeRuntime(rt);
  free(allocated_script);
  return result;
}

int cell_init(int argc, char **argv)
{
  /* Check for --test flag to run C test suite */
  if (argc >= 2 && strcmp(argv[1], "--test") == 0) {
    size_t heap_size = 64 * 1024; /* 64KB default */
    if (argc >= 3) {
      heap_size = strtoull(argv[2], NULL, 0);
      /* Round up to power of 2 for buddy allocator */
      size_t p = 1;
      while (p < heap_size) p <<= 1;
      heap_size = p;
    }
    return run_test_suite(heap_size);
  }

  /* Check for -e or --eval flag to run immediate script */
  /* Also check for -p flag to print bytecode */
  if (argc >= 3 && (strcmp(argv[1], "-e") == 0 || strcmp(argv[1], "--eval") == 0)) {
    return run_eval(argv[2], 0);
  }
  if (argc >= 3 && (strcmp(argv[1], "-p") == 0 || strcmp(argv[1], "--print-bytecode") == 0)) {
    return run_eval(argv[2], 1);
  }

  int script_start = 1;

  /* Find the cell shop at ~/.cell */
  int found = find_cell_shop();
  if (!found) {
    return 1;
  }

  /* Create the initial actor from the command line */
  int actor_argc = argc - script_start;
  char **actor_argv = argv + script_start;

  WotaBuffer startwota;
  wota_buffer_init(&startwota, 5);
  wota_write_record(&startwota, 2);
  wota_write_text(&startwota, "program");
  wota_write_text(&startwota, actor_argv[0]);
  wota_write_text(&startwota, "arg");
  wota_write_array(&startwota, actor_argc - 1);
  for (int i = 1; i < actor_argc; i++)
    wota_write_text(&startwota, actor_argv[i]);
    
  /* Initialize synchronization primitives */
  actor_initialize();
    
  root_cell = create_actor(startwota.data);
#ifndef TARGET_PLAYDATE
  signal(SIGINT, signal_handler);
  signal(SIGTERM, signal_handler);
  signal(SIGSEGV, signal_handler);
  signal(SIGABRT, signal_handler);
#endif  
  actor_loop();

  return 0;
}

int JS_ArrayLength(JSContext *js, JSValue a)
{
  int64_t len;
  JS_GetLength(js, a, &len);
  return len;
}

int js2bool(JSContext *js, JSValue v) { return JS_ToBool(js,v); }
JSValue bool2js(JSContext *js, int b) { return JS_NewBool(js,b); }

JSValue number2js(JSContext *js, double g) { return JS_NewFloat64(js,g); }
double js2number(JSContext *js, JSValue v) {
  double g;
  JS_ToFloat64(js, &g, v);
  if (isnan(g)) g = 0;
  return g;
}

uint64_t cell_random_fit() {
  uint64_t buf;
  randombytes((uint8_t *)&buf, sizeof(buf));
  return buf >> 11;
}

double cell_random() {
  uint64_t buf = cell_random_fit();
  return (double)buf / 9007199254740992.0;
}

void cell_trace_sethook(cell_hook)
{
  
}

int uncaught_exception(JSContext *js, JSValue v)
{
  cell_rt *rt = JS_GetContextOpaque(js);
  if (!JS_HasException(js)) {
    JS_FreeValue(js,v);
    return 1;
  }

  JSValue exp = JS_GetException(js);
  
  JSValue message = JS_GetPropertyStr(js, exp, "message");
  const char *msg_str = JS_ToCString(js, message);
  if (msg_str) {
    printf("Exception: %s\n", msg_str);
    JS_FreeCString(js, msg_str);
  }
  JS_FreeValue(js, message);
  
  JSValue stack = JS_GetPropertyStr(js, exp, "stack");
  const char *stack_str = JS_ToCString(js, stack);
  if (stack_str) {
    printf("Stack:\n%s\n", stack_str);
    JS_FreeCString(js, stack_str);
  }
  JS_FreeValue(js, stack);
  
  JS_FreeValue(js, exp);
  JS_FreeValue(js, v);
  return 0;
}