#include <compat.h> // IWYU pragma: keep

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <uv.h>

#include "errors.h"
#include "runtime.h"
#include "internal.h"

#include "silver/engine.h"
#include "gc/roots.h"
#include "gc/modules.h"
#include "modules/abort.h"
#include "modules/timer.h"
#include "modules/symbol.h"

typedef struct timer_entry {
  uv_timer_t handle;
  ant_value_t callback;
  ant_value_t *args;
  int nargs;
  int timer_id;
  int active;
  int closed;
  int is_interval;
  struct timer_entry *next;
  struct timer_entry *prev;
} timer_entry_t;

typedef struct microtask_entry {
  ant_value_t callback;
  ant_value_t promise;
  struct microtask_entry *next;
  uint8_t argc;
  ant_value_t argv[];
} microtask_entry_t;

typedef struct immediate_entry {
  ant_value_t callback;
  int immediate_id;
  int active;
  struct immediate_entry *next;
} immediate_entry_t;

static struct {
  ant_t *js;
  timer_entry_t *timers;
  
  microtask_entry_t *next_ticks;
  microtask_entry_t *next_ticks_tail;
  microtask_entry_t *next_ticks_processing;
  microtask_entry_t *microtasks;
  microtask_entry_t *microtasks_tail;
  microtask_entry_t *microtasks_processing;
  immediate_entry_t *immediates;
  immediate_entry_t *immediates_tail;
  
  int next_timer_id;
  int next_immediate_id;
  int active_timer_count;
} timer_state = {
  .js = NULL,
  .timers = NULL,
  .next_ticks = NULL,
  .next_ticks_tail = NULL,
  .next_ticks_processing = NULL,
  .microtasks = NULL,
  .microtasks_tail = NULL,
  .microtasks_processing = NULL,
  .immediates = NULL,
  .immediates_tail = NULL,
  .next_timer_id = 1,
  .next_immediate_id = 1,
  .active_timer_count = 0,
};

static ant_value_t g_timeout_proto = 0;
static ant_value_t g_interval_proto = 0;

static void add_timer_entry(timer_entry_t *entry) {
  entry->next = timer_state.timers;
  entry->prev = NULL;
  if (timer_state.timers) timer_state.timers->prev = entry;
  timer_state.timers = entry;
}

static void remove_timer_entry(timer_entry_t *entry) {
  if (entry->prev) entry->prev->next = entry->next;
  else timer_state.timers = entry->next;
  if (entry->next) entry->next->prev = entry->prev;
}

static int timer_entry_is_registered(timer_entry_t *entry) {
  for (timer_entry_t *it = timer_state.timers; it != NULL; it = it->next)
    if (it == entry) return 1;
  return 0;
}

static timer_entry_t *find_timer_entry_by_id(int timer_id) {
  for (timer_entry_t *entry = timer_state.timers; entry != NULL; entry = entry->next)
    if (entry->timer_id == timer_id) return entry;
  return NULL;
}

static int timer_copy_args(timer_entry_t *entry, ant_value_t *args, int nargs) {
  entry->nargs = nargs > 2 ? nargs - 2 : 0;
  if (entry->nargs > 0) {
    entry->args = ant_calloc(sizeof(ant_value_t) * entry->nargs);
    if (!entry->args) return -1;
    memcpy(entry->args, args + 2, sizeof(ant_value_t) * entry->nargs);
  } else entry->args = NULL;
  return 0;
}

static ant_value_t timer_to_primitive(ant_t *js, ant_value_t *args, int nargs) {
  return js_get_slot(js_getthis(js), SLOT_DATA);
}

static ant_value_t timer_inspect(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t this_obj = js_getthis(js);
  ant_value_t id_val = js_get_slot(this_obj, SLOT_DATA);
  int timer_id = vtype(id_val) == T_NUM ? (int)js_getnum(id_val) : 0;

  ant_value_t tag_val = js_get_sym(js, this_obj, get_toStringTag_sym());
  const char *tag = vtype(tag_val) == T_STR ? js_getstr(js, tag_val, NULL) : "Timeout";

  js_inspect_builder_t builder;
  if (!js_inspect_builder_init_dynamic(&builder, js, 128)) {
    return js_mkerr(js, "out of memory");
  }

  bool ok = js_inspect_header(&builder, "%s (%d)", tag, timer_id);
  if (ok) ok = js_inspect_object_body(&builder, this_obj);
  if (ok) ok = js_inspect_close(&builder);
  
  if (!ok) {
    js_inspect_builder_dispose(&builder);
    return js_mkerr(js, "out of memory");
  }

  return js_inspect_builder_result(&builder);
}

static ant_value_t js_timer_ref(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t this_obj = js_getthis(js);
  timer_entry_t *entry = find_timer_entry_by_id((int)js_getnum(js_get_slot(this_obj, SLOT_DATA)));
  if (entry && !entry->closed && !uv_is_closing((uv_handle_t *)&entry->handle))
    uv_ref((uv_handle_t *)&entry->handle);
  return this_obj;
}

static ant_value_t js_timer_unref(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t this_obj = js_getthis(js);
  timer_entry_t *entry = find_timer_entry_by_id((int)js_getnum(js_get_slot(this_obj, SLOT_DATA)));
  if (entry && !entry->closed && !uv_is_closing((uv_handle_t *)&entry->handle))
    uv_unref((uv_handle_t *)&entry->handle);
  return this_obj;
}

static ant_value_t js_timer_has_ref(ant_t *js, ant_value_t *args, int nargs) {
  timer_entry_t *entry = find_timer_entry_by_id((int)js_getnum(js_get_slot(js_getthis(js), SLOT_DATA)));
  if (!entry || entry->closed || uv_is_closing((uv_handle_t *)&entry->handle)) return js_false;
  return js_bool(uv_has_ref((const uv_handle_t *)&entry->handle) != 0);
}

static ant_value_t timer_make_object(ant_t *js, int id, double delay_ms, int is_interval, ant_value_t callback) {
  ant_value_t obj = js_mkobj(js);
  ant_value_t proto = is_interval ? g_interval_proto : g_timeout_proto;

  if (is_object_type(proto)) js_set_proto_init(obj, proto);

  js_set(js, obj, "delay", js_mknum(delay_ms));
  js_set(js, obj, "repeat", is_interval ? js_mknum(delay_ms) : js_mknull());
  
  js_set(js, obj, "callback", callback);
  js_set_descriptor(js, obj, "callback", 8, JS_DESC_W | JS_DESC_C);
  
  js_set_slot(obj, SLOT_DATA, js_mknum((double)id));
  js_set_sym(js, obj, get_toPrimitive_sym(), js_mkfun(timer_to_primitive));

  return obj;
}

static int timer_id_from_arg(ant_t *js, ant_value_t arg) {
  if (vtype(arg) == T_NUM) return (int)js_getnum(arg);
  return (int)js_getnum(js_get_slot(arg, SLOT_DATA));
}

static void timer_close_cb(uv_handle_t *h) {
  timer_entry_t *entry = (timer_entry_t *)h->data;
  if (!entry) return;
  if (entry->closed) return;
  if (timer_entry_is_registered(entry)) remove_timer_entry(entry);
  entry->closed = 1;
  entry->active = 0;
  entry->callback = 0;
  entry->next = NULL;
  entry->prev = NULL;
  
  if (entry->args) {
    free(entry->args);
    entry->args = NULL;
  }
  entry->nargs = 0;
}

static void timer_callback(uv_timer_t *handle) {
  timer_entry_t *entry = (timer_entry_t *)handle->data;
  if (!entry || entry->closed || !timer_entry_is_registered(entry) || !entry->active) return;
  
  ant_t *js = timer_state.js;
  if (!entry->is_interval) {
    entry->active = 0;
    timer_state.active_timer_count--;
  }

  sv_vm_call(js->vm, js, entry->callback, js_mkundef(), entry->args, entry->nargs, NULL, false);
  process_microtasks(js);
  
  if (!entry->is_interval) if (!uv_is_closing((uv_handle_t *)&entry->handle)) uv_close(
    (uv_handle_t *)&entry->handle, timer_close_cb
  );
}

// setTimeout(callback, delay, ...args)
static ant_value_t js_set_timeout(ant_t *js, ant_value_t *args, int nargs) {
  if (nargs < 1) {
    return js_mkerr(js, "setTimeout requires at least 1 argument (callback)");
  }
  
  ant_value_t callback = args[0];
  double delay_ms = nargs > 1 ? js_getnum(args[1]) : 0;
  uint64_t ms = delay_ms >= 1 ? (uint64_t)delay_ms : 0;
  
  timer_entry_t *entry = ant_calloc(sizeof(timer_entry_t));
  if (entry == NULL) return js_mkerr(js, "failed to allocate timer");
  
  if (timer_copy_args(entry, args, nargs) < 0) {
    free(entry);
    return js_mkerr(js, "failed to allocate timer args");
  }
  
  uv_timer_init(uv_default_loop(), &entry->handle);
  entry->handle.data = entry;
  entry->callback = callback;
  entry->timer_id = timer_state.next_timer_id++;
  entry->active = 1;
  entry->closed = 0;
  entry->is_interval = 0;
  
  add_timer_entry(entry);
  timer_state.active_timer_count++;
  uv_timer_start(&entry->handle, timer_callback, ms, 0);

  return timer_make_object(js, entry->timer_id, delay_ms, 0, callback);
}

// setInterval(callback, delay, ...args)
static ant_value_t js_set_interval(ant_t *js, ant_value_t *args, int nargs) {
  if (nargs < 1) {
    return js_mkerr(js, "setInterval requires at least 1 argument (callback)");
  }
  
  ant_value_t callback = args[0];
  double delay_ms = nargs > 1 ? js_getnum(args[1]) : 0;
  uint64_t ms = delay_ms >= 1 ? (uint64_t)delay_ms : 1;
  
  timer_entry_t *entry = ant_calloc(sizeof(timer_entry_t));
  if (entry == NULL) return js_mkerr(js, "failed to allocate timer");
  
  if (timer_copy_args(entry, args, nargs) < 0) {
    free(entry);
    return js_mkerr(js, "failed to allocate timer args");
  }
  
  uv_timer_init(uv_default_loop(), &entry->handle);
  entry->handle.data = entry;
  entry->callback = callback;
  entry->timer_id = timer_state.next_timer_id++;
  entry->active = 1;
  entry->closed = 0;
  entry->is_interval = 1;
  
  add_timer_entry(entry);
  timer_state.active_timer_count++;
  uv_timer_start(&entry->handle, timer_callback, ms, ms);

  return timer_make_object(js, entry->timer_id, delay_ms, 1, callback);
}

// clearTimeout(timerId | timerObject)
static ant_value_t js_clear_timeout(ant_t *js, ant_value_t *args, int nargs) {
  if (nargs < 1) return js_mkundef();
  int timer_id = timer_id_from_arg(js, args[0]);
  
  for (timer_entry_t *entry = timer_state.timers; entry != NULL; entry = entry->next) {
  if (entry->timer_id == timer_id && entry->active) {
    entry->active = 0; timer_state.active_timer_count--;
    if (!uv_is_closing((uv_handle_t *)&entry->handle)) uv_close((uv_handle_t *)&entry->handle, timer_close_cb);
    break;
  }}
  
  return js_mkundef();
}

// setImmediate(callback)
static ant_value_t js_set_immediate(ant_t *js, ant_value_t *args, int nargs) {
  if (nargs < 1) {
    return js_mkerr(js, "setImmediate requires 1 argument (callback)");
  }
  
  ant_value_t callback = args[0];
  
  immediate_entry_t *entry = ant_calloc(sizeof(immediate_entry_t));
  if (entry == NULL) {
    return js_mkerr(js, "failed to allocate immediate");
  }
  
  entry->callback = callback;
  entry->immediate_id = timer_state.next_immediate_id++;
  entry->active = 1;
  entry->next = NULL;
  
  if (timer_state.immediates_tail == NULL) {
    timer_state.immediates = entry;
    timer_state.immediates_tail = entry;
  } else {
    timer_state.immediates_tail->next = entry;
    timer_state.immediates_tail = entry;
  }

  ant_value_t obj = js_mkobj(js);
  js_set(js, obj, "id", js_mknum((double)entry->immediate_id));
  js_set(js, obj, "callback", callback);
  
  return obj;
}

// clearImmediate(immediateId | immediateObject)
static ant_value_t js_clear_immediate(ant_t *js, ant_value_t *args, int nargs) {
  if (nargs < 1) return js_mkundef();
  int immediate_id = timer_id_from_arg(js, args[0]);
  
  for (immediate_entry_t *entry = timer_state.immediates; entry != NULL; entry = entry->next) {
    if (entry->immediate_id == immediate_id) { entry->active = 0; break; }
  }
  
  return js_mkundef();
}

// queueMicrotask(callback)
static ant_value_t js_queue_microtask(ant_t *js, ant_value_t *args, int nargs) {
  if (nargs < 1) {
    return js_mkerr(js, "queueMicrotask requires 1 argument (callback)");
  }
  
  queue_microtask(js, args[0]);
  return js_mkundef();
}

static ant_value_t timers_promises_get_state(ant_t *js) {
  return js_get_slot(js->current_func, SLOT_DATA);
}

static ant_value_t timers_promises_abort_reason(ant_t *js, ant_value_t signal) {
  ant_value_t reason = abort_signal_get_reason(signal);
  if (vtype(reason) != T_UNDEF && vtype(reason) != T_NULL) return reason;
  return js_mkerr_typed(js, JS_ERR_TYPE, "The operation was aborted");
}

static void timers_promises_remove_abort_listener(ant_t *js, ant_value_t state) {
  ant_value_t signal = 0;
  ant_value_t listener = 0;

  if (!is_object_type(state)) return;

  signal = js_get(js, state, "signal");
  listener = js_get(js, state, "abortListener");

  if (abort_signal_is_signal(signal) && is_callable(listener))
    abort_signal_remove_listener(js, signal, listener);

  js_set(js, state, "abortListener", js_mkundef());
}

static void timers_promises_settle(ant_t *js, ant_value_t state, bool reject, ant_value_t value) {
  ant_value_t settled = 0;
  ant_value_t promise = 0;

  if (!is_object_type(state)) return;

  settled = js_get(js, state, "settled");
  if (js_truthy(js, settled)) return;

  js_set(js, state, "settled", js_true);
  timers_promises_remove_abort_listener(js, state);
  js_set(js, state, "handle", js_mkundef());

  promise = js_get(js, state, "promise");
  if (reject) js_reject_promise(js, promise, value);
  else js_resolve_promise(js, promise, value);
}

static ant_value_t timers_promises_resolve(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t state = timers_promises_get_state(js);
  ant_value_t value = js_mkundef();
  if (!is_object_type(state)) return js_mkundef();
  value = js_get(js, state, "value");
  timers_promises_settle(js, state, false, value);
  return js_mkundef();
}

static ant_value_t timers_promises_on_abort(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t state = timers_promises_get_state(js);
  ant_value_t signal = 0;
  ant_value_t handle = 0;
  ant_value_t is_immediate = 0;
  ant_value_t reason = js_mkundef();
  ant_value_t clear_args[1];

  if (!is_object_type(state)) return js_mkundef();

  signal = js_get(js, state, "signal");
  handle = js_get(js, state, "handle");
  is_immediate = js_get(js, state, "isImmediate");

  if (vtype(handle) != T_UNDEF && vtype(handle) != T_NULL) {
    clear_args[0] = handle;
    if (js_truthy(js, is_immediate)) js_clear_immediate(js, clear_args, 1);
    else js_clear_timeout(js, clear_args, 1);
  }

  if (abort_signal_is_signal(signal)) reason = timers_promises_abort_reason(js, signal);
  else reason = js_mkerr_typed(js, JS_ERR_TYPE, "The operation was aborted");

  timers_promises_settle(js, state, true, reason);
  return js_mkundef();
}

static bool timers_promises_parse_options(
  ant_t *js,
  ant_value_t value,
  ant_value_t *signal_out,
  ant_value_t *error_out
) {
  ant_value_t signal = js_mkundef();

  if (signal_out) *signal_out = js_mkundef();
  if (error_out) *error_out = js_mkundef();

  if (vtype(value) == T_UNDEF || vtype(value) == T_NULL) return true;
  if (vtype(value) != T_OBJ) {
    if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "Timer options must be an object");
    return false;
  }

  signal = js_get(js, value, "signal");
  if (vtype(signal) != T_UNDEF && vtype(signal) != T_NULL && !abort_signal_is_signal(signal)) {
    if (error_out) *error_out = js_mkerr_typed(js, JS_ERR_TYPE, "options.signal must be an AbortSignal");
    return false;
  }

  if (signal_out) *signal_out = signal;
  return true;
}

static ant_value_t timers_promises_schedule(
  ant_t *js,
  double delay_ms,
  ant_value_t value,
  ant_value_t signal,
  bool is_immediate
) {
  ant_value_t promise = js_mkpromise(js);
  ant_value_t state = js_mkobj(js);
  ant_value_t callback = 0;
  ant_value_t handle = 0;
  ant_value_t args[2];

  if (abort_signal_is_signal(signal) && abort_signal_is_aborted(signal)) {
    js_reject_promise(js, promise, timers_promises_abort_reason(js, signal));
    return promise;
  }

  js_set(js, state, "promise", promise);
  js_set(js, state, "value", value);
  js_set(js, state, "signal", signal);
  js_set(js, state, "abortListener", js_mkundef());
  js_set(js, state, "handle", js_mkundef());
  js_set(js, state, "settled", js_false);
  js_set(js, state, "isImmediate", js_bool(is_immediate));

  callback = js_heavy_mkfun(js, timers_promises_resolve, state);
  if (is_immediate) handle = js_set_immediate(js, &callback, 1);
  else {
    args[0] = callback;
    args[1] = js_mknum(delay_ms);
    handle = js_set_timeout(js, args, 2);
  }

  if (is_err(handle)) {
    js_reject_promise(js, promise, handle);
    return promise;
  }

  js_set(js, state, "handle", handle);

  if (abort_signal_is_signal(signal)) {
    ant_value_t listener = js_heavy_mkfun(js, timers_promises_on_abort, state);
    js_set(js, state, "abortListener", listener);
    abort_signal_add_listener(js, signal, listener);
  }

  return promise;
}

static ant_value_t js_timers_promises_setTimeout(ant_t *js, ant_value_t *args, int nargs) {
  double delay_ms = nargs > 0 ? js_getnum(args[0]) : 0;
  ant_value_t value = nargs > 1 ? args[1] : js_mkundef();
  ant_value_t options = nargs > 2 ? args[2] : js_mkundef();
  ant_value_t signal = js_mkundef();
  ant_value_t error = js_mkundef();

  if (!timers_promises_parse_options(js, options, &signal, &error)) return error;
  return timers_promises_schedule(js, delay_ms, value, signal, false);
}

static ant_value_t js_timers_promises_setImmediate(ant_t *js, ant_value_t *args, int nargs) {
  ant_value_t value = nargs > 0 ? args[0] : js_mkundef();
  ant_value_t options = nargs > 1 ? args[1] : js_mkundef();
  ant_value_t signal = js_mkundef();
  ant_value_t error = js_mkundef();

  if (!timers_promises_parse_options(js, options, &signal, &error)) return error;
  return timers_promises_schedule(js, 0, value, signal, true);
}

static ant_value_t js_timers_promises_setInterval(ant_t *js, ant_value_t *args, int nargs) {
  return js_mkerr_typed(js, JS_ERR_TYPE, "node:timers/promises setInterval() is not implemented yet");
}

static ant_value_t js_timers_promises_scheduler_wait(ant_t *js, ant_value_t *args, int nargs) {
  return js_timers_promises_setTimeout(js, args, nargs);
}

static ant_value_t js_timers_promises_scheduler_yield(ant_t *js, ant_value_t *args, int nargs) {
  return js_timers_promises_setImmediate(js, args, nargs);
}

static void queue_microtask_entry(
  microtask_entry_t **head,
  microtask_entry_t **tail,
  microtask_entry_t *entry
) {
  if (*tail == NULL) goto empty;

  (*tail)->next = entry;
  *tail = entry;
  return;

empty:
  *head = entry;
  *tail = entry;
}

void queue_microtask(ant_t *js, ant_value_t callback) {
  microtask_entry_t *entry = ant_calloc(sizeof(microtask_entry_t));
  if (entry == NULL) return;
  
  entry->callback = callback;
  entry->promise = js_mkundef();
  entry->next = NULL;
  entry->argc = 0;
  
  queue_microtask_entry(&timer_state.microtasks, &timer_state.microtasks_tail, entry);
}

void queue_microtask_with_args(ant_t *js, ant_value_t callback, ant_value_t *args, int nargs) {
  if (nargs <= 0) { queue_microtask(js, callback); return; }
  
  microtask_entry_t *entry = ant_calloc(sizeof(microtask_entry_t) + (size_t)nargs * sizeof(ant_value_t));
  if (entry == NULL) return;
  
  entry->callback = callback;
  entry->promise = js_mkundef();
  entry->next = NULL;
  entry->argc = (uint8_t)nargs;
  
  for (int i = 0; i < nargs; i++) entry->argv[i] = args[i];
  queue_microtask_entry(&timer_state.microtasks, &timer_state.microtasks_tail, entry);
}

void queue_next_tick(ant_t *js, ant_value_t callback) {
  microtask_entry_t *entry = ant_calloc(sizeof(microtask_entry_t));
  if (entry == NULL) return;

  entry->callback = callback;
  entry->promise = js_mkundef();
  entry->next = NULL;
  entry->argc = 0;

  queue_microtask_entry(&timer_state.next_ticks, &timer_state.next_ticks_tail, entry);
}

void queue_next_tick_with_args(ant_t *js, ant_value_t callback, ant_value_t *args, int nargs) {
  if (nargs <= 0) { queue_next_tick(js, callback); return; }

  microtask_entry_t *entry = ant_calloc(sizeof(microtask_entry_t) + (size_t)nargs * sizeof(ant_value_t));
  if (entry == NULL) return;

  entry->callback = callback;
  entry->promise = js_mkundef();
  entry->next = NULL;
  entry->argc = (uint8_t)nargs;

  for (int i = 0; i < nargs; i++) entry->argv[i] = args[i];
  queue_microtask_entry(&timer_state.next_ticks, &timer_state.next_ticks_tail, entry);
}

void queue_promise_trigger(ant_t *js, ant_value_t promise) {
  if (!js_mark_promise_trigger_queued(js, promise)) return;

  microtask_entry_t *entry = ant_calloc(sizeof(microtask_entry_t));
  if (entry == NULL) {
    js_mark_promise_trigger_dequeued(js, promise);
    return;
  }
  
  entry->callback = js_mkundef();
  entry->promise = promise;
  entry->next = NULL;
  
  queue_microtask_entry(&timer_state.microtasks, &timer_state.microtasks_tail, entry);
}

static inline void process_microtask_entry(ant_t *js, microtask_entry_t *entry) {
  if (!entry) return;

  if (vtype(entry->promise) == T_PROMISE) {
    GC_ROOT_SAVE(root_mark, js);
    ant_value_t promise = entry->promise;
    
    GC_ROOT_PIN(js, promise);
    js_mark_promise_trigger_dequeued(js, promise);
    js_process_promise_handlers(js, promise);
    GC_ROOT_RESTORE(js, root_mark);
    
    return;
  }

  GC_ROOT_SAVE(root_mark, js);
  ant_value_t callback = entry->callback;
  GC_ROOT_PIN(js, callback);
  
  for (uint8_t i = 0; i < entry->argc; i++) GC_ROOT_PIN(js, entry->argv[i]);
  sv_vm_call(js->vm, js, callback, js_mkundef(), entry->argv, entry->argc, NULL, false);
  GC_ROOT_RESTORE(js, root_mark);
}

static inline microtask_entry_t *take_microtask_batch(void) {
  microtask_entry_t *batch = timer_state.microtasks;

  timer_state.microtasks = NULL;
  timer_state.microtasks_tail = NULL;
  timer_state.microtasks_processing = batch;
  
  return batch;
}

static inline microtask_entry_t *take_next_tick_batch(void) {
  microtask_entry_t *batch = timer_state.next_ticks;

  timer_state.next_ticks = NULL;
  timer_state.next_ticks_tail = NULL;
  timer_state.next_ticks_processing = batch;
  
  return batch;
}

static inline void process_microtask_batch(ant_t *js, microtask_entry_t *batch) {
while (batch != NULL) {
  microtask_entry_t *entry = batch;
  batch = entry->next;
  timer_state.microtasks_processing = batch;
  process_microtask_entry(js, entry);
  free(entry);
}}

static inline void process_next_tick_batch(ant_t *js, microtask_entry_t *batch) {
while (batch != NULL) {
  microtask_entry_t *entry = batch;
  batch = entry->next;
  timer_state.next_ticks_processing = batch;
  process_microtask_entry(js, entry);
  free(entry);
}}

static void process_microtasks_internal(ant_t *js, bool check_unhandled_rejections) {
  microtask_entry_t *batch = NULL;

  if (!js || js->microtasks_draining) return;
  js->microtasks_draining = true;

  while (timer_state.next_ticks != NULL || timer_state.microtasks != NULL) {
  while ((batch = timer_state.next_ticks) != NULL) {
    batch = take_next_tick_batch();
    process_next_tick_batch(js, batch);
  }
  while ((batch = timer_state.microtasks) != NULL) {
    batch = take_microtask_batch();
    process_microtask_batch(js, batch);
  }}

  timer_state.next_ticks_processing = NULL;
  timer_state.microtasks_processing = NULL;
  if (check_unhandled_rejections) js_check_unhandled_rejections(js);
  js->microtasks_draining = false;
  reap_retired_coroutines();
}

void process_microtasks(ant_t *js) {
  process_microtasks_internal(js, true);
}

bool js_maybe_drain_microtasks(ant_t *js) {
  if (!js) return false;
  if (js->microtasks_draining) return false;
  if (js->vm_exec_depth != 0) return false;
  if (!has_pending_microtasks()) return false;
  process_microtasks_internal(js, true);
  return true;
}

bool js_maybe_drain_microtasks_after_async_settle(ant_t *js) {
  if (!js) return false;

  if (js->microtasks_draining) return false;
  if (!has_pending_microtasks()) return false;

  process_microtasks_internal(js, false);
  return true;
}

void process_immediates(ant_t *js) {
while (timer_state.immediates != NULL) {
  immediate_entry_t *entry = timer_state.immediates;
  timer_state.immediates = entry->next;
  
  if (timer_state.immediates == NULL) {
    timer_state.immediates_tail = NULL;
  }
  
  if (entry->active) {
    ant_value_t args[0];
    sv_vm_call(js->vm, js, entry->callback, js_mkundef(), args, 0, NULL, false);
    process_microtasks(js);
  }
  
  free(entry);
}}

int has_pending_immediates(void) {
  for (
    immediate_entry_t *entry = timer_state.immediates;
    entry != NULL; entry = entry->next
  ) if (entry->active) return 1;
  return 0;
}

int has_pending_timers(void) {
  return timer_state.active_timer_count > 0;
}

int has_pending_microtasks(void) {
  return (timer_state.next_ticks != NULL || timer_state.microtasks != NULL) ? 1 : 0;
}

static void timers_define_common(ant_t *js, ant_value_t obj) {
  js_set(js, obj, "setTimeout", js_mkfun_flags(js_set_timeout, CFUNC_HAS_PROTOTYPE));
  js_set(js, obj, "clearTimeout", js_mkfun_flags(js_clear_timeout, CFUNC_HAS_PROTOTYPE));
  js_set(js, obj, "setInterval", js_mkfun_flags(js_set_interval, CFUNC_HAS_PROTOTYPE));
  js_set(js, obj, "clearInterval", js_mkfun_flags(js_clear_timeout, CFUNC_HAS_PROTOTYPE));
  js_set(js, obj, "setImmediate", js_mkfun_flags(js_set_immediate, CFUNC_HAS_PROTOTYPE));
  js_set(js, obj, "clearImmediate", js_mkfun_flags(js_clear_immediate, CFUNC_HAS_PROTOTYPE));
  js_set(js, obj, "queueMicrotask", js_mkfun(js_queue_microtask));
}

void init_timer_module() {  
  ant_t *js = rt->js;
  timer_state.js = js;

  g_timeout_proto = js_mkobj(js);
  g_interval_proto = js_mkobj(js);
  gc_register_root(&g_timeout_proto);
  gc_register_root(&g_interval_proto);

  js_set_proto_init(g_timeout_proto, js->sym.object_proto);
  js_set(js, g_timeout_proto, "ref", js_mkfun(js_timer_ref));
  js_set(js, g_timeout_proto, "unref", js_mkfun(js_timer_unref));
  js_set(js, g_timeout_proto, "hasRef", js_mkfun(js_timer_has_ref));
  js_set_sym(js, g_timeout_proto, get_toStringTag_sym(), js_mkstr(js, "Timeout", 7));
  js_set_sym(js, g_timeout_proto, get_inspect_sym(), js_mkfun(timer_inspect));

  js_set_proto_init(g_interval_proto, js->sym.object_proto);
  js_set(js, g_interval_proto, "ref", js_mkfun(js_timer_ref));
  js_set(js, g_interval_proto, "unref", js_mkfun(js_timer_unref));
  js_set(js, g_interval_proto, "hasRef", js_mkfun(js_timer_has_ref));
  js_set_sym(js, g_interval_proto, get_toStringTag_sym(), js_mkstr(js, "Interval", 8));
  js_set_sym(js, g_interval_proto, get_inspect_sym(), js_mkfun(timer_inspect));

  timers_define_common(js, js_glob(js));
}

ant_value_t timers_library(ant_t *js) {
  ant_value_t lib = js_mkobj(js);

  timers_define_common(js, lib);
  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "timers", 6));

  return lib;
}

// TODO: mostly stubbed
ant_value_t timers_promises_library(ant_t *js) {
  ant_value_t lib = js_mkobj(js);
  ant_value_t scheduler = js_mkobj(js);

  js_set(js, lib, "scheduler", scheduler);
  js_set(js, lib, "setTimeout", js_mkfun(js_timers_promises_setTimeout));
  js_set(js, lib, "setImmediate", js_mkfun(js_timers_promises_setImmediate));
  js_set(js, lib, "setInterval", js_mkfun(js_timers_promises_setInterval));
  js_set(js, scheduler, "wait", js_mkfun(js_timers_promises_scheduler_wait));
  js_set(js, scheduler, "yield", js_mkfun(js_timers_promises_scheduler_yield));
  js_set_sym(js, lib, get_toStringTag_sym(), js_mkstr(js, "timers/promises", 16));

  return lib;
}

void gc_mark_timers(ant_t *js, gc_mark_fn mark) {
  if (is_object_type(g_timeout_proto)) mark(js, g_timeout_proto);
  if (is_object_type(g_interval_proto)) mark(js, g_interval_proto);
  for (timer_entry_t *t = timer_state.timers; t; t = t->next) {
    mark(js, t->callback);
    for (int i = 0; i < t->nargs; i++) mark(js, t->args[i]);
  }
  for (microtask_entry_t *m = timer_state.microtasks; m; m = m->next) {
    mark(js, m->callback);
    mark(js, m->promise);
    for (uint8_t i = 0; i < m->argc; i++) mark(js, m->argv[i]);
  }
  for (microtask_entry_t *m = timer_state.microtasks_processing; m; m = m->next) {
    mark(js, m->callback);
    mark(js, m->promise);
    for (uint8_t i = 0; i < m->argc; i++) mark(js, m->argv[i]);
  }
  for (microtask_entry_t *m = timer_state.next_ticks; m; m = m->next) {
    mark(js, m->callback);
    mark(js, m->promise);
    for (uint8_t i = 0; i < m->argc; i++) mark(js, m->argv[i]);
  }
  for (microtask_entry_t *m = timer_state.next_ticks_processing; m; m = m->next) {
    mark(js, m->callback);
    mark(js, m->promise);
    for (uint8_t i = 0; i < m->argc; i++) mark(js, m->argv[i]);
  }
  for (immediate_entry_t *i = timer_state.immediates; i; i = i->next) {
    mark(js, i->callback);
  }
}