#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <math.h>
#include <yyjson.h>

#include "gc/roots.h"
#include "cfunc.h"
#include "utf8.h"
#include "numbers.h"
#include "hash.h"
#include "errors.h"
#include "internal.h"

#include "silver/call.h"
#include "modules/json.h"

static inline bool json_value_needs_temp_root(ant_value_t value) {
  if (!is_tagged(value)) return false;
  
  static const uint32_t mask =
    (1u << kTypeString) | (1u << kTypeObject) | (1u << kTypeArray) | (1u << kTypeFunction) |
    (1u << kTypePromise) | (1u << kTypeGenerator) | (1u << kTypeSymbol) | (1u << kTypeBigInt);
    
  uint8_t t = vtype(value);
  return t < 32 && (mask >> t) & 1;
}

static inline bool json_temp_pin(gc_temp_root_scope_t *roots, ant_value_t value) {
  if (!json_value_needs_temp_root(value)) return true;
  return gc_temp_root_handle_valid(gc_temp_root_add(roots, value));
}

static inline ant_value_t json_parse_oom(ant_t *js) {
  return js_mkerr(js, "JSON.parse() failed: out of memory");
}

static inline ant_value_t json_stringify_oom(ant_t *js) {
  return js_mkerr(js, "JSON.stringify() failed: out of memory");
}

static inline bool json_read_hex4(const char *p, uint32_t *out) {
  uint32_t value = 0;
  
  for (int k = 0; k < 4; k++) {
    unsigned char c = (unsigned char)p[k];
    uint32_t digit;
    if (c >= '0' && c <= '9') digit = c - '0';
    else if ((c | 0x20) >= 'a' && (c | 0x20) <= 'f') digit = (c | 0x20) - 'a' + 10;
    else return false;
    value = (value << 4) | digit;
  }
  
  *out = value;
  return true;
}

/*
 * yyjson built standard-only rejects lone surrogate escapes
 * (\uD800..\uDFFF without a partner) and raw WTF-8 surrogate bytes, both of
 * which JSON.parse must accept. When a parse fails on an invalid string, the
 * text is rewritten so each lone surrogate becomes a U+FFFF marker plus four
 * hex digits (a genuine U+FFFF is doubled), parsed again in standard mode, and
 * the markers are decoded back into WTF-8 inside the document's own strings.
 * Valid input never takes this path.
 */
#define JSON_MARK "\xEF\xBF\xBF"
#define JSON_MARK_LEN 3

static inline bool json_is_mark(const char *p) {
  return (unsigned char)p[0] == 0xEF && (unsigned char)p[1] == 0xBF && (unsigned char)p[2] == 0xBF;
}

static inline size_t json_write_marked(char *dst, uint32_t cu) {
  static const char hex[] = "0123456789abcdef";
  memcpy(dst, JSON_MARK, JSON_MARK_LEN);
  dst[3] = hex[(cu >> 12) & 15];
  dst[4] = hex[(cu >> 8) & 15];
  dst[5] = hex[(cu >> 4) & 15];
  dst[6] = hex[cu & 15];
  return 7;
}

static inline size_t json_write_wtf8(char *dst, uint32_t cu) {
  dst[0] = (char)(0xE0 | (cu >> 12));
  dst[1] = (char)(0x80 | ((cu >> 6) & 0x3F));
  dst[2] = (char)(0x80 | (cu & 0x3F));
  return 3;
}

static char *json_surrogate_rewrite(const char *src, size_t len, size_t *out_len) {
  if (len > SIZE_MAX / 3 - 1) return NULL;
  char *dst = malloc(len * 3 + 1);
  if (!dst) return NULL;

  size_t i = 0, n = 0;
  bool in_str = false;

  while (i < len) {
    unsigned char c = (unsigned char)src[i];

    if (!in_str || c == '"') {
      if (c == '"') in_str = !in_str;
      dst[n++] = (char)c;
      i++;
      continue;
    }

    if (c == 0xED && i + 3 <= len) {
      unsigned char c1 = (unsigned char)src[i + 1], c2 = (unsigned char)src[i + 2];
      if (c1 >= 0xA0 && c1 <= 0xBF && (c2 & 0xC0) == 0x80) {
        n += json_write_marked(dst + n, ((c & 0x0F) << 12) | ((c1 & 0x3F) << 6) | (c2 & 0x3F));
        i += 3;
        continue;
      }
    }

    if (c == 0xEF && i + 3 <= len && json_is_mark(src + i)) {
      memcpy(dst + n, JSON_MARK JSON_MARK, 2 * JSON_MARK_LEN);
      n += 2 * JSON_MARK_LEN;
      i += 3;
      continue;
    }

    if (c != '\\') {
      dst[n++] = (char)c;
      i++;
      continue;
    }

    uint32_t hi, lo;
    if (i + 6 > len || src[i + 1] != 'u' || !json_read_hex4(src + i + 2, &hi)) {
      size_t take = i + 2 <= len ? 2 : 1;
      memcpy(dst + n, src + i, take);
      n += take;
      i += take;
      continue;
    }

    if (hi == 0xFFFF) {
      memcpy(dst + n, JSON_MARK JSON_MARK, 2 * JSON_MARK_LEN);
      n += 2 * JSON_MARK_LEN;
      i += 6;
      continue;
    }

    if ((hi & 0xF800) != 0xD800) {
      memcpy(dst + n, src + i, 6);
      n += 6;
      i += 6;
      continue;
    }

    if (
      hi <= 0xDBFF && i + 12 <= len && src[i + 6] == '\\' && src[i + 7] == 'u' &&
      json_read_hex4(src + i + 8, &lo) && (lo & 0xFC00) == 0xDC00
    ) {
      memcpy(dst + n, src + i, 12);
      n += 12;
      i += 12;
      continue;
    }

    n += json_write_marked(dst + n, hi);
    i += 6;
  }

  *out_len = n;
  return dst;
}

static void json_surrogate_decode(yyjson_doc *doc) {
  yyjson_val *vals = yyjson_doc_get_root(doc);
  size_t count = yyjson_doc_get_val_count(doc);

  for (size_t k = 0; k < count; k++) {
    yyjson_val *val = vals + k;
    if (!yyjson_is_str(val)) continue;

    size_t len = yyjson_get_len(val);
    char *str = (char *)yyjson_get_str(val);
    size_t r = 0;
    
    while (r + JSON_MARK_LEN <= len && !json_is_mark(str + r)) r++;
    if (r + JSON_MARK_LEN > len) continue;

    size_t w = r;
    while (r < len) {
      if (len - r >= 2 * JSON_MARK_LEN && json_is_mark(str + r) && json_is_mark(str + r + JSON_MARK_LEN)) {
        memcpy(str + w, JSON_MARK, JSON_MARK_LEN);
        w += JSON_MARK_LEN;
        r += 2 * JSON_MARK_LEN;
        continue;
      }
      
      uint32_t cu;
      if (len - r >= 7 && json_is_mark(str + r) && json_read_hex4(str + r + JSON_MARK_LEN, &cu)) {
        w += json_write_wtf8(str + w, cu);
        r += 7;
        continue;
      }
      
      str[w++] = str[r++];
    }

    str[w] = '\0';
    yyjson_set_strn(val, str, w);
  }
}

static yyjson_doc *json_read_doc(const char *str, size_t len) {
  yyjson_read_err err;
  yyjson_doc *doc = yyjson_read_opts((char *)str, len, 0, NULL, &err);
  if (doc || err.code != YYJSON_READ_ERROR_INVALID_STRING) return doc;

  size_t rewritten_len = 0;
  char *rewritten = json_surrogate_rewrite(str, len, &rewritten_len);
  if (!rewritten) return NULL;

  doc = yyjson_read_opts(rewritten, rewritten_len, 0, NULL, NULL);
  free(rewritten);
  if (doc) json_surrogate_decode(doc);
  
  return doc;
}

static bool json_shape_matches(ant_shape_t *shape, yyjson_val *val) {
  if (!shape || ant_shape_count(shape) != yyjson_obj_size(val)) return false;
  size_t idx, max;
  yyjson_val *key, *item;
  
  yyjson_obj_foreach(val, idx, max, key, item) {
    const ant_shape_prop_t *prop = ant_shape_prop_at(shape, (uint32_t)idx);
    if (!prop || prop->type != ANT_SHAPE_KEY_STRING ||
        prop->attrs != ANT_PROP_ATTR_DEFAULT || prop->has_getter || prop->has_setter ||
        intern_length(prop->key.interned) != yyjson_get_len(key) ||
        memcmp(prop->key.interned, yyjson_get_str(key), yyjson_get_len(key)) != 0)
      return false;
  }
  
  return true;
}

void json_layout_cache_clear(ant_t *js) {
  json_layout_cache_t *cache = js->json_layout_cache;
  if (!cache) return;
  for (unsigned i = 0; i < cache->count; i++) 
    ant_shape_release(cache->entries[i].shape);
  free(cache);
  js->json_layout_cache = NULL;
}

static uint64_t json_layout_hash(yyjson_val *val, size_t *key_bytes) {
  uint64_t hash = yyjson_obj_size(val);
  *key_bytes = 0;
  size_t idx, max;
  yyjson_val *key, *item;
  yyjson_obj_foreach(val, idx, max, key, item) {
    size_t len = yyjson_get_len(key);
    hash = ant_hash_mix(hash ^ hash_key(yyjson_get_str(key), len), len + 1);
    if (len >= JSON_LAYOUT_CACHE_BYTES - *key_bytes) *key_bytes = JSON_LAYOUT_CACHE_BYTES;
    else *key_bytes += len + 1;
  }
  return hash;
}

static ant_shape_t *json_layout_cache_find(ant_t *js, yyjson_val *val, uint64_t hash) {
  json_layout_cache_t *cache = js->json_layout_cache;
  if (!cache) return NULL;
  for (unsigned i = 0; i < cache->count; i++) {
    json_layout_cache_entry_t entry = cache->entries[i];
    if (entry.hash != hash || !json_shape_matches(entry.shape, val)) continue;
    memmove(cache->entries + 1, cache->entries, i * sizeof(entry));
    cache->entries[0] = entry;
    return entry.shape;
  }
  return NULL;
}

static void json_layout_cache_insert(ant_t *js, ant_shape_t *shape, uint64_t hash, size_t key_bytes) {
  size_t bytes = ant_shape_storage_bytes(shape);
  if (key_bytes >= JSON_LAYOUT_CACHE_BYTES || bytes > JSON_LAYOUT_CACHE_BYTES - key_bytes) return;
  bytes += key_bytes;
  if (!js->json_layout_cache) js->json_layout_cache = calloc(1, sizeof(json_layout_cache_t));
  json_layout_cache_t *cache = js->json_layout_cache;
  if (!cache) return;
  while (cache->count && (cache->count == JSON_LAYOUT_CACHE_ENTRIES || cache->bytes + bytes > JSON_LAYOUT_CACHE_BYTES)) {
    json_layout_cache_entry_t *entry = &cache->entries[--cache->count];
    cache->bytes -= entry->bytes;
    ant_shape_release(entry->shape);
  }
  memmove(cache->entries + 1, cache->entries, cache->count * sizeof(*cache->entries));
  ant_shape_retain(shape);
  cache->entries[0] = (json_layout_cache_entry_t){ .shape = shape, .hash = hash, .bytes = bytes };
  cache->count++;
  cache->bytes += bytes;
}

static bool json_prepare_object(
  ant_t *js, ant_object_t *obj, yyjson_val *val,
  ant_shape_t *expected, bool *duplicates
) {
  *duplicates = false;
  if (json_shape_matches(expected, val)) {
    ant_shape_transition_existing(&obj->shape, expected);
    return js_obj_ensure_prop_capacity(js, obj, ant_shape_count(expected));
  }

  size_t count = yyjson_obj_size(val);
  bool bulk = count >= JSON_BULK_LAYOUT_MIN_PROPS;
  uint64_t hash = 0;
  size_t key_bytes = 0;
  
  if (bulk) {
    hash = json_layout_hash(val, &key_bytes);
    ant_shape_t *cached = json_layout_cache_find(js, val, hash);
    if (cached) {
      ant_shape_transition_existing(&obj->shape, cached);
      return js_obj_ensure_prop_capacity(js, obj, ant_shape_count(cached));
    }
    ant_shape_t *shape = ant_shape_clone_bulk(obj->shape, (uint32_t)count);
    if (!shape) return false;
    ant_shape_release(obj->shape);
    obj->shape = shape;
  }

  size_t idx, max;
  yyjson_val *key, *item;
  yyjson_obj_foreach(val, idx, max, key, item) {
    const char *interned = intern_string(js, yyjson_get_str(key), yyjson_get_len(key));
    if (!interned) return false;
    uint32_t slot;
    int32_t found = ant_shape_lookup_interned(obj->shape, interned);
    if (found >= 0) slot = (uint32_t)found;
    else {
      bool added = bulk
        ? ant_shape_add_interned(js, obj->shape, interned, ANT_PROP_ATTR_DEFAULT, &slot)
        : ant_shape_add_interned_tr(js, &obj->shape, interned, ANT_PROP_ATTR_DEFAULT, &slot);
      if (!added) return false;
    }
    if (slot != idx) *duplicates = true;
  }
  
  if (!js_obj_ensure_prop_capacity(js, obj, ant_shape_count(obj->shape))) return false;
  if (bulk && !*duplicates) json_layout_cache_insert(js, obj->shape, hash, key_bytes);
  
  return true;
}

static ant_value_t yyjson_to_jsval(
  ant_t *js, yyjson_val *val, gc_temp_root_scope_t *roots, ant_shape_t *expected
) {
  if (!val) return js_mkundef();
  
  switch (yyjson_get_type(val)) {
  case YYJSON_TYPE_NULL: return js_mknull();
  case YYJSON_TYPE_BOOL: return js_bool(yyjson_get_bool(val));
  
  case YYJSON_TYPE_STR: {
    ant_value_t str = js_mkstr(js, yyjson_get_str(val), yyjson_get_len(val));
    if (is_err(str)) return str;
    if (!json_temp_pin(roots, str)) return json_parse_oom(js);
    return str;
  }
  
  case YYJSON_TYPE_NUM: {
    if (yyjson_is_sint(val)) return js_mknum((double)yyjson_get_sint(val));
    if (yyjson_is_uint(val)) return js_mknum((double)yyjson_get_uint(val));
    return js_mknum(yyjson_get_real(val));
  }
  
  case YYJSON_TYPE_ARR: {
    ant_value_t arr = js_mkarr(js);
    if (is_err(arr)) return arr;
    if (!json_temp_pin(roots, arr)) return json_parse_oom(js);

    size_t count = yyjson_arr_size(val);
    if (count > MAX_DENSE_INITIAL_CAP) js_arr_reserve(js, arr, (uint32_t)count);

    size_t idx, max;
    yyjson_val *item;
    size_t mark = roots->len;
    ant_shape_t *previous = NULL;

    yyjson_arr_foreach(val, idx, max, item) {
      ant_value_t elem = yyjson_to_jsval(js, item, roots, previous);
      if (is_err(elem)) {
        ant_shape_release(previous);
        return elem;
      }
      js_arr_push(js, arr, elem);
      if (vtype(elem) == kTypeObject) {
        ant_shape_t *next = js_obj_ptr(elem)->shape;
        ant_shape_retain(next);
        ant_shape_release(previous);
        previous = next;
      }
      gc_temp_root_truncate(roots, mark);
    }

    ant_shape_release(previous);
    return arr;
  }
  
  case YYJSON_TYPE_OBJ: {
    ant_value_t obj = Ant_Object_Create(js);
    if (is_err(obj)) return obj;
    if (!json_temp_pin(roots, obj)) return json_parse_oom(js);

    ant_object_t *ptr = js_obj_ptr(js_as_obj(obj));
    size_t count = yyjson_obj_size(val);
    if (count > UINT32_MAX) return json_parse_oom(js);
    
    bool prepared = expected || count >= JSON_BULK_LAYOUT_MIN_PROPS;
    bool duplicates = false;
    
    if (prepared) {
      if (!json_prepare_object(js, ptr, val, expected, &duplicates)) return json_parse_oom(js);
    } else if (count > 1 && !js_obj_ensure_prop_capacity(js, ptr, (uint32_t)count)) return json_parse_oom(js);

    size_t idx, max; yyjson_val *key, *item;
    size_t mark = roots->len;

    yyjson_obj_foreach(val, idx, max, key, item) {
      ant_value_t v = yyjson_to_jsval(js, item, roots, NULL);
      if (is_err(v)) return v;
      if (!prepared) {
        if (is_err(mkprop_append_fast(js, obj, yyjson_get_str(key), yyjson_get_len(key), v)))
          return json_parse_oom(js);
        gc_temp_root_truncate(roots, mark);
        continue;
      }
      uint32_t slot = (uint32_t)idx;
      if (duplicates) {
        const char *interned = intern_find(js, yyjson_get_str(key), yyjson_get_len(key));
        int32_t found = ant_shape_lookup_interned(ptr->shape, interned);
        assert(found >= 0);
        slot = (uint32_t)found;
      }
      ant_object_prop_set_unchecked(ptr, slot, v);
      gc_write_barrier(js, ptr, v);
      gc_temp_root_truncate(roots, mark);
    }

    return obj;
  }
  
  default: return js_mkundef(); }
}

typedef struct {
  ant_t *js;
  ant_value_t *stack;
  ant_value_t replacer_func;
  ant_value_t replacer_arr;
  ant_value_t error;
  ant_value_t holder;
  ant_value_t cycle_start;
  
  gc_temp_root_scope_t temp_roots;
  gc_temp_root_handle_t error_handle;
  gc_temp_root_handle_t holder_handle;
  
  int stack_size;
  int stack_cap;
  int replacer_arr_len;
  int has_cycle;
  bool has_error;
  char cycle_key[128];

  char indent[64];
  size_t indent_len;

  const char *tojson_key;
  ant_value_t tojson_proto;
  uint32_t tojson_epoch;
  bool tojson_absent;
} json_cycle_ctx;

static inline bool json_has_abort(json_cycle_ctx *ctx) {
  return ctx->has_cycle || ctx->has_error;
}

static void json_set_error(json_cycle_ctx *ctx, ant_value_t value) {
  ctx->has_error = true;
  ctx->error = value;
  gc_temp_root_set(ctx->error_handle, value);
}

static inline bool json_ctx_pin_value(json_cycle_ctx *ctx, ant_value_t value) {
  if (json_temp_pin(&ctx->temp_roots, value)) return true;
  json_set_error(ctx, json_stringify_oom(ctx->js));
  return false;
}

static inline void json_set_holder(json_cycle_ctx *ctx, ant_value_t value) {
  ctx->holder = value;
  gc_temp_root_set(ctx->holder_handle, value);
}

static void json_capture_error(json_cycle_ctx *ctx, ant_value_t value) {
  if (ctx->has_error) return;
  if (!is_err(value) && Ant_Exception_Pending(ctx->js))
    value = Ant_Exception_Current(ctx->js);
  json_set_error(ctx, value);
  if (Ant_Exception_Peek(ctx->js) == value) Ant_Exception_Clear(ctx->js);
}

typedef struct {
  char *buf;
  size_t len;
  size_t cap;
  bool oom;
} json_out_t;

static bool json_out_reserve(json_out_t *o, size_t extra) {
  if (o->oom) return false;
  if (o->len + extra <= o->cap) return true;

  size_t want = o->cap ? o->cap : 256;
  while (want < o->len + extra) {
    size_t next = want * 2;
    if (next < want) { o->oom = true; return false; }
    want = next;
  }

  char *next = realloc(o->buf, want);
  if (!next) { o->oom = true; return false; }

  o->buf = next;
  o->cap = want;
  
  return true;
}

static bool json_out_write(json_out_t *o, const char *src, size_t n) {
  if (!json_out_reserve(o, n)) return false;
  memcpy(o->buf + o->len, src, n);
  o->len += n;
  return true;
}

static bool json_out_char(json_out_t *o, char c) {
  if (!json_out_reserve(o, 1)) return false;
  o->buf[o->len++] = c;
  return true;
}

static bool json_out_quoted_raw(json_out_t *o, const char *str, size_t byte_len) {
  size_t i = 0;
  while (i < byte_len) {
    unsigned char c = (unsigned char)str[i];
    if (c < 0x20 || c == '"' || c == '\\' || c >= 0x80) break;
    i++;
  }

  if (i == byte_len) {
    if (!json_out_reserve(o, byte_len + 2)) return false;
    o->buf[o->len++] = '"';
    memcpy(o->buf + o->len, str, byte_len);
    o->len += byte_len;
    o->buf[o->len++] = '"';
    return true;
  }

  size_t raw_len = 0;
  char *raw = utf8_json_quote(str, byte_len, &raw_len);
  if (!raw) { o->oom = true; return false; }

  bool ok = json_out_write(o, raw, raw_len);
  free(raw);
  
  return ok;
}

static bool json_out_quoted(ant_t *js, json_out_t *o, ant_value_t value) {
  size_t byte_len = 0;
  char *str = js_getstr(js, value, &byte_len);
  if (!str) { o->oom = true; return false; }
  return json_out_quoted_raw(o, str, byte_len);
}

static bool json_out_number(json_out_t *o, double num) {
  if (isnan(num) || isinf(num)) return json_out_write(o, "null", 4);
  if (!json_out_reserve(o, 48)) return false;
  char *p = o->buf + o->len;

  if (
    num >= -9007199254740992.0 &&
    num <= 9007199254740992.0 && 
    (double)(int64_t)num == num
  ) {
    int64_t as_int = (int64_t)num;
    uint64_t u;
    
    if (as_int < 0) {
      *p++ = '-';
      u = (uint64_t)(-(as_int + 1)) + 1u;
    } else u = (uint64_t)as_int;

    char tmp[20];
    size_t n = 0;
    do { tmp[n++] = (char)('0' + (u % 10)); u /= 10; } while (u);
    while (n) *p++ = tmp[--n];

    o->len = (size_t)(p - o->buf);
    return true;
  }

  o->len += ant_number_to_shortest(num, p, 48);
  return true;
}

static int json_cycle_check(json_cycle_ctx *ctx, ant_value_t val, const char *key) {
  for (int i = 0; i < ctx->stack_size; i++) if (ctx->stack[i] == val) {
    ctx->has_cycle = 1;
    ctx->cycle_start = val;
    snprintf(ctx->cycle_key, sizeof(ctx->cycle_key), "%s", key ? key : "");
    return 1;
  }
  return 0;
}

static ant_value_t json_cycle_error(ant_t *js, const json_cycle_ctx *ctx) {
  const char *ctor = ctx->cycle_start == js->global ? "global" : "Object";
  char message[384];
  snprintf(
    message, sizeof(message),
    "Converting circular structure to JSON\n"
    "    --> starting at object with constructor '%s'\n"
    "    --- property '%s' closes the circle",
    ctor,
    ctx->cycle_key
  );
  return js_mkerr_typed(js, JS_ERR_TYPE, "%s", message);
}

static void json_cycle_push(json_cycle_ctx *ctx, ant_value_t val) {
  if (ctx->stack_size >= ctx->stack_cap) {
    ctx->stack_cap = ctx->stack_cap ? ctx->stack_cap * 2 : 16;
    ctx->stack = realloc(ctx->stack, ctx->stack_cap * sizeof(ant_value_t));
  }
  ctx->stack[ctx->stack_size++] = val;
}

static inline void json_cycle_pop(json_cycle_ctx *ctx) {
  if (ctx->stack_size > 0) ctx->stack_size--;
}

static inline int key_matches(const char *a, size_t a_len, const char *b, size_t b_len) {
  return a_len == b_len && memcmp(a, b, a_len) == 0;
}

static inline ant_value_t json_snapshot_keys(ant_t *js, ant_value_t value) {
  if (!is_special_object(value)) return js_mkarr(js);
  return js_for_in_keys(js, value);
}

static int is_key_in_replacer_arr(ant_t *js, json_cycle_ctx *ctx, const char *key, size_t key_len) {
  if (!is_special_object(ctx->replacer_arr)) return 1;
  
  for (int i = 0; i < ctx->replacer_arr_len; i++) {
  char idxstr[32];
  snprintf(idxstr, sizeof(idxstr), "%d", i);
  
  ant_value_t item = js_get(js, ctx->replacer_arr, idxstr);
  if (is_err(item)) {
    json_capture_error(ctx, item);
    return 0;
  }
  
  int type = vtype(item);
  if (type == kTypeString) {
    size_t item_len;
    char *item_str = js_getstr(js, item, &item_len);
    if (key_matches(item_str, item_len, key, key_len)) return 1;
  } else if (type == kTypeNumber) {
    char numstr[32];
    snprintf(numstr, sizeof(numstr), "%.0f", js_getnum(item));
    if (key_matches(numstr, strlen(numstr), key, key_len)) return 1;
  }}
  
  return 0;
}

typedef enum { 
  JSON_W_OK,
  JSON_W_SKIP,
  JSON_W_ABORT 
} json_write_t;

static json_write_t json_write_with_key(
  json_cycle_ctx *ctx, json_out_t *out, const char *key,
  ant_value_t val, int in_array, int depth
);
  
static ant_value_t apply_reviver(
  ant_t *js, ant_value_t holder,
  const char *key, ant_value_t reviver,
  gc_temp_root_scope_t *roots
);

static ant_value_t json_apply_tojson(
  ant_t *js,
  const char *key,
  ant_value_t val,
  json_cycle_ctx *ctx
) {
  bool bigint = vtype(val) == kTypeBigInt;
  if (!bigint && !is_special_object(val)) return val;

  ant_value_t toJSON = js_mkundef();
  bool needs_generic = bigint || is_proxy(val);
  ant_prop_loc_t found = ANT_PROP_LOC_NONE;

  if (!needs_generic) {
    found = lkp_interned(val, ctx->tojson_key);

    if (!found.obj) {
      ant_value_t proto = js_get_proto(js, val);
      bool known_absent =
        ctx->tojson_proto == proto &&
        ctx->tojson_epoch == js->ic.epoch &&
        ctx->tojson_absent;

      if (!known_absent && is_object_type(proto)) {
        found = lkp_proto(js, proto, "toJSON", 6);
        ctx->tojson_proto = proto;
        ctx->tojson_epoch = js->ic.epoch;
        ctx->tojson_absent = !found.obj;
      }
    }

    if (found.obj) {
      const ant_shape_prop_t *meta = ant_shape_prop_at(found.obj->shape, found.slot);
      if (meta && (meta->has_getter || meta->has_setter)) needs_generic = true;
      else toJSON = js_prop_load(found);
    }
  }

  if (needs_generic) {
    ant_value_t generic = js_get(js, val, "toJSON");
    if (is_err(generic)) {
      json_capture_error(ctx, generic);
      return js_mkundef();
    }
    toJSON = generic;
  }

  if (!is_callable(toJSON)) return val;
  ant_value_t key_arg = js_mkstr(js, key, strlen(key));
  if (is_err(key_arg)) {
    json_capture_error(ctx, key_arg);
    return js_mkundef();
  }
  
  if (!json_ctx_pin_value(ctx, key_arg)) return js_mkundef();
  ant_value_t args[1] = { key_arg };
  
  ant_value_t transformed = sv_vm_call(
    js->vm, js,
    toJSON, val,
    args, 1, NULL, js_mkundef()
  );
  
  if (is_err(transformed)) {
    json_capture_error(ctx, transformed);
    return js_mkundef();
  }
  if (!json_ctx_pin_value(ctx, transformed)) return js_mkundef();

  return transformed;
}

static ant_value_t json_apply_replacer(
  ant_t *js,
  const char *key,
  ant_value_t val,
  json_cycle_ctx *ctx
) {
  if (!is_callable(ctx->replacer_func)) return val;
  ant_value_t key_arg = js_mkstr(js, key, strlen(key));
  if (is_err(key_arg)) {
    json_capture_error(ctx, key_arg);
    return js_mkundef();
  }
  if (!json_ctx_pin_value(ctx, key_arg)) return js_mkundef();
  ant_value_t args[2] = { key_arg, val };
  
  ant_value_t transformed = sv_vm_call(
    js->vm, js, 
    ctx->replacer_func, ctx->holder, 
    args, 2, NULL, js_mkundef()
  );
  
  if (is_err(transformed)) {
    json_capture_error(ctx, transformed);
    return js_mkundef();
  }
  if (!json_ctx_pin_value(ctx, transformed)) return js_mkundef();

  return transformed;
}

static inline ant_value_t json_create_root_holder(ant_t *js, ant_value_t value, json_cycle_ctx *ctx) {
  ant_value_t holder = Ant_Object_CreateBare(js);
  if (is_err(holder)) return holder;
  if (!json_ctx_pin_value(ctx, holder)) return js_mkundef();
  js_set(js, holder, "", value);
  return holder;
}

static bool json_write_indent(json_cycle_ctx *ctx, json_out_t *out, int depth) {
  if (!ctx->indent_len) return true;
  if (!json_out_char(out, '\n')) return false;
  for (int i = 0; i < depth; i++)
    if (!json_out_write(out, ctx->indent, ctx->indent_len)) return false;
  return true;
}

static json_write_t json_write_array(
  json_cycle_ctx *ctx, json_out_t *out, ant_value_t val, int depth
) {
  ant_t *js = ctx->js;
  ant_offset_t length = js_arr_len(js, val);
  ant_value_t saved_holder = ctx->holder;

  if (!json_out_char(out, '[')) return JSON_W_ABORT;
  json_set_holder(ctx, val);
  bool has_replacer = is_callable(ctx->replacer_func);

  for (ant_offset_t i = 0; i < length; i++) {
    char idxstr[32];

    if (i && !json_out_char(out, ',')) goto abort;
    if (!json_write_indent(ctx, out, depth + 1)) goto abort;
    ant_value_t elem = js_arr_get(js, val, i);

    if (is_err(elem) || Ant_Exception_Pending(js)) {
      json_capture_error(ctx, elem);
      goto abort;
    }

    if (has_replacer || is_special_object(elem) || vtype(elem) == kTypeBigInt) uint_to_str(idxstr, sizeof(idxstr), (uint64_t)i);
    else idxstr[0] = '\0';

    json_write_t w = json_write_with_key(ctx, out, idxstr, elem, 1, depth + 1);
    if (w == JSON_W_ABORT) goto abort;
    if (w == JSON_W_SKIP && !json_out_write(out, "null", 4)) goto abort;
  }

  if (length && !json_write_indent(ctx, out, depth)) goto abort;
  if (!json_out_char(out, ']')) goto abort;

  json_set_holder(ctx, saved_holder);
  return JSON_W_OK;

abort:
  json_set_holder(ctx, saved_holder);
  return JSON_W_ABORT;
}

static bool json_key_is_index(const char *key) {
  if (!key || !*key) return false;
  if (key[0] == '0') return key[1] == '\0';
  for (const char *p = key; *p; p++) if (*p < '0' || *p > '9') return false;
  return true;
}

static bool json_collect_own_keys(
  ant_t *js, ant_value_t val, const char ***out_keys, size_t *out_count,
  const char **inline_keys, size_t inline_cap
) {
  if (vtype(val) != kTypeObject || is_proxy(val)) return false;

  ant_object_t *ptr = js_obj_ptr(js_as_obj(val));
  if (!ptr || !ptr->shape || ptr->flags.is_exotic) return false;

  uint32_t count = ant_shape_count(ptr->shape);
  const char **keys = inline_keys;
  size_t n = 0;

  if (count > inline_cap) {
    keys = malloc(sizeof(*keys) * count);
    if (!keys) return false;
  }

  for (uint32_t i = 0; i < count; i++) {
    const ant_shape_prop_t *prop = ant_shape_prop_at(ptr->shape, i);
    if (!prop || prop->type != ANT_SHAPE_KEY_STRING) continue;
    if (!(prop->attrs & ANT_PROP_ATTR_ENUMERABLE)) continue;

    if (json_key_is_index(prop->key.interned)) {
      if (keys != inline_keys) free(keys);
      return false;
    }
    keys[n++] = prop->key.interned;
  }

  *out_keys = keys;
  *out_count = n;
  return true;
}

static json_write_t json_write_object_fast(
  json_cycle_ctx *ctx, json_out_t *out, ant_value_t val, int depth,
  const char **keys, size_t key_count
) {
  ant_t *js = ctx->js;
  ant_value_t saved_holder = ctx->holder;
  bool wrote_any = false;

  if (!json_out_char(out, '{')) return JSON_W_ABORT;
  json_set_holder(ctx, val);

  for (size_t i = 0; i < key_count; i++) {
    const char *key = keys[i];
    size_t key_len = intern_length(key);

    bool included = is_key_in_replacer_arr(js, ctx, key, key_len);
    if (json_has_abort(ctx)) goto abort;
    if (!included) continue;

    ant_prop_loc_t loc = lkp_interned(val, key);
    if (!loc.obj) continue;

    ant_value_t prop;
    const ant_shape_prop_t *meta = ant_shape_prop_at(loc.obj->shape, loc.slot);

    if (meta && (meta->has_getter || meta->has_setter)) {
      prop = js_get(js, val, key);
      if (is_err(prop)) {
        json_capture_error(ctx, prop);
        goto abort;
      }
    } else prop = js_prop_load(loc);

    if (!json_ctx_pin_value(ctx, prop)) goto abort;
    size_t mark = out->len;

    if (wrote_any && !json_out_char(out, ',')) goto abort;
    if (!json_write_indent(ctx, out, depth + 1)) goto abort;
    if (!json_out_quoted_raw(out, key, key_len)) goto abort;
    if (!json_out_char(out, ':')) goto abort;
    if (ctx->indent_len && !json_out_char(out, ' ')) goto abort;

    json_write_t w = json_write_with_key(ctx, out, key, prop, 0, depth + 1);
    if (w == JSON_W_ABORT) goto abort;
    if (w == JSON_W_SKIP) { out->len = mark; continue; }

    wrote_any = true;
  }

  if (wrote_any && !json_write_indent(ctx, out, depth)) goto abort;
  if (!json_out_char(out, '}')) goto abort;

  json_set_holder(ctx, saved_holder);
  return JSON_W_OK;

abort:
  json_set_holder(ctx, saved_holder);
  return JSON_W_ABORT;
}

static json_write_t json_write_object(
  json_cycle_ctx *ctx, json_out_t *out, ant_value_t val, int depth
) {
  ant_t *js = ctx->js;

  const char *inline_keys[24];
  const char **fast_keys = NULL;
  size_t fast_count = 0;

  if (json_collect_own_keys(js, val, &fast_keys, &fast_count, inline_keys, 24)) {
    json_write_t w = json_write_object_fast(ctx, out, val, depth, fast_keys, fast_count);
    if (fast_keys != inline_keys) free((void *)fast_keys);
    return w;
  }

  ant_value_t keys = json_snapshot_keys(js, val);
  ant_value_t saved_holder = ctx->holder;
  bool wrote_any = false;

  if (is_err(keys)) {
    json_capture_error(ctx, keys);
    return JSON_W_ABORT;
  }
  
  if (!json_ctx_pin_value(ctx, keys)) return JSON_W_ABORT;
  if (!json_out_char(out, '{')) return JSON_W_ABORT;
  json_set_holder(ctx, val);

  ant_offset_t key_count = js_arr_len(js, keys);
  for (ant_offset_t i = 0; i < key_count; i++) {
    ant_value_t key_val = js_arr_get(js, keys, i);
    size_t key_len = 0;
    char *key = js_getstr(js, key_val, &key_len);

    if (!key) continue;
    bool included = is_key_in_replacer_arr(js, ctx, key, key_len);
    if (json_has_abort(ctx)) goto abort;
    if (!included) continue;

    ant_value_t prop = js_get(js, val, key);
    if (is_err(prop)) {
      json_capture_error(ctx, prop);
      goto abort;
    }
    if (!json_ctx_pin_value(ctx, prop)) goto abort;

    size_t mark = out->len;

    if (wrote_any && !json_out_char(out, ',')) goto abort;
    if (!json_write_indent(ctx, out, depth + 1)) goto abort;
    if (!json_out_quoted_raw(out, key, key_len)) goto abort;
    if (!json_out_char(out, ':')) goto abort;
    if (ctx->indent_len && !json_out_char(out, ' ')) goto abort;

    json_write_t w = json_write_with_key(ctx, out, key, prop, 0, depth + 1);
    if (w == JSON_W_ABORT) goto abort;
    if (w == JSON_W_SKIP) { out->len = mark; continue; }

    wrote_any = true;
  }

  if (wrote_any && !json_write_indent(ctx, out, depth)) goto abort;
  if (!json_out_char(out, '}')) goto abort;

  json_set_holder(ctx, saved_holder);
  return JSON_W_OK;

abort:
  json_set_holder(ctx, saved_holder);
  return JSON_W_ABORT;
}

static json_write_t json_write_impl(
  json_cycle_ctx *ctx, json_out_t *out, const char *key,
  ant_value_t val, int in_array, int depth
) {
  json_write_t result;

  switch (vtype(val)) {
    case kTypeNull: return json_out_write(out, "null", 4) ? JSON_W_OK : JSON_W_ABORT;
    case kTypeBool:
      return json_out_write(out, val == js_true ? "true" : "false", val == js_true ? 4 : 5)
        ? JSON_W_OK : JSON_W_ABORT;

    case kTypeUndefined:
    case kTypeFunction:
    case kTypeBuiltin:
    case kTypeSymbol:
      return in_array ? (json_out_write(out, "null", 4) ? JSON_W_OK : JSON_W_ABORT) : JSON_W_SKIP;

    case kTypeBigInt:
      json_capture_error(ctx, js_mkerr_typed(ctx->js, JS_ERR_TYPE,"Do not know how to serialize a BigInt"));
      return JSON_W_ABORT;

    case kTypeNumber: return json_out_number(out, js_getnum(val)) ? JSON_W_OK : JSON_W_ABORT;
    case kTypeString: return json_out_quoted(ctx->js, out, val) ? JSON_W_OK : JSON_W_ABORT;

    case kTypeObject:
    case kTypeArray: break;
    default: return json_out_write(out, "null", 4) ? JSON_W_OK : JSON_W_ABORT;
  }

  if (vtype(val) == kTypeObject) {
    ant_value_t prim = js_get_slot(val, SLOT_PRIMITIVE);
    switch (vtype(prim)) {
      case kTypeNumber:  return json_out_number(out, js_getnum(prim)) ? JSON_W_OK : JSON_W_ABORT;
      case kTypeString:  return json_out_quoted(ctx->js, out, prim) ? JSON_W_OK : JSON_W_ABORT;
      case kTypeBool: return json_out_write(out, prim == js_true ? "true" : "false", prim == js_true ? 4 : 5) ? JSON_W_OK : JSON_W_ABORT;

      case kTypeBigInt:
        json_capture_error(ctx, js_mkerr_typed(ctx->js, JS_ERR_TYPE, "Do not know how to serialize a BigInt"));
        return JSON_W_ABORT;

      default: break;
    }
  }

  if (depth >= 2000) {
    json_capture_error(ctx, js_mkerr_typed(ctx->js, JS_ERR_RANGE, "Maximum call stack size exceeded"));
    return JSON_W_ABORT;
  }

  if (json_cycle_check(ctx, val, key)) return JSON_W_ABORT;
  json_cycle_push(ctx, val);

  result = is_array_value(val)
    ? json_write_array(ctx, out, val, depth)
    : json_write_object(ctx, out, val, depth);

  json_cycle_pop(ctx);
  return result;
}

static json_write_t json_write_with_key(
  json_cycle_ctx *ctx, json_out_t *out, const char *key,
  ant_value_t val, int in_array, int depth
) {
  val = json_apply_tojson(ctx->js, key, val, ctx);
  if (json_has_abort(ctx)) return JSON_W_ABORT;

  val = json_apply_replacer(ctx->js, key, val, ctx);
  if (json_has_abort(ctx)) return JSON_W_ABORT;

  return json_write_impl(ctx, out, key, val, in_array, depth);
}

static ant_value_t apply_reviver_call(
  ant_t *js,
  ant_value_t holder,
  const char *key,
  ant_value_t reviver,
  gc_temp_root_scope_t *roots
) {
  ant_value_t key_str = js_mkstr(js, key, strlen(key));
  if (is_err(key_str)) return key_str;
  if (!json_temp_pin(roots, key_str)) return json_parse_oom(js);
  ant_value_t current_value = js_get(js, holder, key);
  ant_value_t call_args[2] = { key_str, current_value };
  
  ant_value_t result = sv_vm_call(
    js->vm, js, reviver, holder,
    call_args, 2, NULL, js_mkundef()
  );
  if (!is_err(result) && !json_temp_pin(roots, result)) return json_parse_oom(js);
  
  return result;
}

static void apply_reviver_to_array(
  ant_t *js,
  ant_value_t value,
  ant_value_t reviver,
  gc_temp_root_scope_t *roots
) {
  ant_offset_t length = js_arr_len(js, value);

  for (ant_offset_t i = 0; i < length; i++) {
  char idxstr[32];
  size_t idx_len = uint_to_str(idxstr, sizeof(idxstr), (uint64_t)i);
  ant_value_t new_elem = apply_reviver(js, value, idxstr, reviver, roots);
  if (vtype(new_elem) == kTypeUndefined) js_delete_prop(js, value, idxstr, idx_len);
  else {
    ant_value_t key_val = js_mkstr(js, idxstr, idx_len);
    if (is_err(key_val)) return;
    if (!json_temp_pin(roots, key_val)) return;
    js_setprop(js, value, key_val, new_elem);
  }}
}

static void apply_reviver_to_object(
  ant_t *js,
  ant_value_t value,
  ant_value_t reviver,
  gc_temp_root_scope_t *roots
) {
  ant_value_t keys = json_snapshot_keys(js, value);
  if (is_err(keys) || vtype(keys) != kTypeArray) return;
  if (!json_temp_pin(roots, keys)) return;

  ant_offset_t key_count = js_arr_len(js, keys);
  for (ant_offset_t i = 0; i < key_count; i++) {
    ant_value_t key_val = js_arr_get(js, keys, i);
    size_t key_len = 0;
    char *key = js_getstr(js, key_val, &key_len);
    if (!key) continue;
    ant_value_t new_val = apply_reviver(js, value, key, reviver, roots);
    if (vtype(new_val) == kTypeUndefined) js_delete_prop(js, value, key, key_len);
    else js_set(js, value, key, new_val);
  }
}

static ant_value_t apply_reviver(
  ant_t *js,
  ant_value_t holder,
  const char *key,
  ant_value_t reviver,
  gc_temp_root_scope_t *roots
) {
  ant_value_t val = js_get(js, holder, key);
  
  if (is_array_value(val)) apply_reviver_to_array(js, val, reviver, roots);
  else if (vtype(val) == kTypeObject) apply_reviver_to_object(js, val, reviver, roots);

  return apply_reviver_call(js, holder, key, reviver, roots);
}

ant_value_t js_json_parse(ant_params_t) {
  if (nargs < 1) return js_mkerr(js, "JSON.parse() requires at least 1 argument");
  if (vtype(args[0]) != kTypeString) return js_mkerr(js, "JSON.parse() argument must be a string");
  
  gc_temp_root_scope_t temp_roots;
  gc_temp_root_scope_begin(js, &temp_roots);
  
  size_t len;
  char *json_str = js_getstr(js, args[0], &len);
  yyjson_doc *doc = json_read_doc(json_str, len);

  if (!doc) {
    gc_temp_root_scope_end(&temp_roots);
    return js_mkerr_typed(js, JS_ERR_SYNTAX, "JSON.parse: unexpected character");
  }
  
  ant_value_t result = yyjson_to_jsval(js, yyjson_doc_get_root(doc), &temp_roots, NULL);
  yyjson_doc_free(doc);
  if (is_err(result)) {
    gc_temp_root_scope_end(&temp_roots);
    return result;
  }
  
  if (nargs >= 2 && is_callable(args[1])) {
    ant_value_t reviver = args[1];
    if (!json_temp_pin(&temp_roots, reviver)) {
      gc_temp_root_scope_end(&temp_roots);
      return json_parse_oom(js);
    }
    ant_value_t root = Ant_Object_CreateBare(js);
    if (is_err(root)) {
      gc_temp_root_scope_end(&temp_roots);
      return root;
    }
    if (!json_temp_pin(&temp_roots, root)) {
      gc_temp_root_scope_end(&temp_roots);
      return json_parse_oom(js);
    }
    js_set(js, root, "", result);
    result = apply_reviver(js, root, "", reviver, &temp_roots);
  }
  
  gc_temp_root_scope_end(&temp_roots);
  return result;
}

ant_value_t json_parse_value(ant_t *js, ant_value_t value) {
  ant_value_t args[1] = { value };
  return js_json_parse(js, args, 1, js_mkundef());
}

static bool json_set_replacer(ant_t *js, json_cycle_ctx *ctx, ant_value_t replacer, ant_value_t *error_out) {
  if (is_callable(replacer)) {
    ctx->replacer_func = replacer;
    if (json_ctx_pin_value(ctx, replacer)) return true;
    *error_out = ctx->error;
    return false;
  }
  
  if (!is_object_type(replacer)) return true;

  bool replacer_is_array = false;
  ant_value_t checked = js_is_array_value_checked(js, replacer, &replacer_is_array);
  
  if (is_err(checked)) {
    *error_out = checked;
    return false;
  }
  
  if (!replacer_is_array) return true;
  ant_value_t len_val = js_get(js, replacer, "length");
  
  if (is_err(len_val)) {
    json_capture_error(ctx, len_val);
    *error_out = js_throw(js, ctx->error);
    return false;
  }
  
  if (vtype(len_val) != kTypeNumber) return true;

  ctx->replacer_arr = replacer;
  ctx->replacer_arr_len = (int)js_getnum(len_val);
  
  if (json_ctx_pin_value(ctx, replacer)) return true;
  *error_out = ctx->error;
  
  return false;
}

static bool json_set_indent(ant_t *js, json_cycle_ctx *ctx, ant_value_t *args, int nargs) {
  ctx->indent_len = 0;
  if (nargs < 3) return true;
  ant_value_t space = args[2];

  if (is_special_object(space)) {
    uint8_t boxed = vtype(js_get_slot(space, SLOT_PRIMITIVE));
    if (boxed != kTypeNumber && boxed != kTypeString) return true;

    ant_value_t prim = boxed == kTypeNumber
      ? js_to_primitive(js, space, 0)
      : js_tostring_val(js, space);

    if (is_err(prim) || Ant_Exception_Pending(js)) {
      json_capture_error(ctx, prim);
      return false;
    }
    space = prim;
  }

  if (vtype(space) == kTypeNumber) {
    double d = js_getnum(space);
    if (isnan(d) || d < 1) return true;
    size_t n = d > 10 ? 10 : (size_t)d;
    memset(ctx->indent, ' ', n);
    ctx->indent_len = n;
    return true;
  }

  if (vtype(space) != kTypeString) return true;

  size_t byte_len = 0;
  char *str = js_getstr(js, space, &byte_len);
  if (!str || !byte_len) return true;

  size_t units = (size_t)str_utf16_len(js, space);
  size_t take = byte_len;

  if (units > 10) {
    size_t char_bytes = 0;
    int off = utf16_index_to_byte_offset(str, byte_len, 10, &char_bytes);
    if (off >= 0) take = (size_t)off;
  }
  if (take > sizeof(ctx->indent)) take = sizeof(ctx->indent);

  memcpy(ctx->indent, str, take);
  ctx->indent_len = take;
  
  return true;
}

ant_value_t js_json_stringify(ant_params_t) {
  ant_value_t result;
  json_out_t out = {0};
  
  json_cycle_ctx ctx = {
    .js = js,
    .replacer_func = js_mkundef(),
    .replacer_arr = js_mkundef(),
    .error = js_mkundef(),
    .holder = js_mkundef(),
  };
  
  ant_value_t root_holder = js_mkundef();
  if (nargs < 1) return js_mkerr(js, "JSON.stringify() requires at least 1 argument");
  
  ctx.tojson_key = intern_string(js, "toJSON", 6);
  gc_temp_root_scope_begin(js, &ctx.temp_roots);
  ctx.error_handle = gc_temp_root_add(&ctx.temp_roots, ctx.error);
  ctx.holder_handle = gc_temp_root_add(&ctx.temp_roots, ctx.holder);
  
  if (!gc_temp_root_handle_valid(ctx.error_handle) || !gc_temp_root_handle_valid(ctx.holder_handle)) {
    gc_temp_root_scope_end(&ctx.temp_roots);
    return json_stringify_oom(js);
  }
  
  if (!json_ctx_pin_value(&ctx, args[0])) {
    result = ctx.error;
    goto cleanup;
  }
  
  int top_type = vtype(args[0]);
  
  if (nargs < 2 && top_type == kTypeString) {
    size_t byte_len = 0;
    size_t raw_len = 0;
    
    char *str = js_getstr(js, args[0], &byte_len);
    char *raw = utf8_json_quote(str, byte_len, &raw_len);
    
    if (!raw) {
      result = js_mkerr(js, "JSON.stringify() failed: out of memory");
      goto cleanup;
    }
    result = js_mkstr(js, raw, raw_len);
    free(raw);
    goto cleanup;
  }
  
  if (nargs >= 2 && !json_set_replacer(js, &ctx, args[1], &result)) goto cleanup;
  
  if (!json_set_indent(js, &ctx, args, nargs)) {
    ant_value_t error = ctx.error;
    result = is_err(error) ? error : js_throw(js, error);
    goto cleanup;
  }

  root_holder = json_create_root_holder(js, args[0], &ctx);
  if (is_err(root_holder)) {
    result = root_holder;
    goto cleanup;
  }
  
  if (vtype(root_holder) == kTypeUndefined && ctx.has_error) {
    result = ctx.error;
    goto cleanup;
  }
  
  json_set_holder(&ctx, root_holder);
  json_write_t root = json_write_with_key(&ctx, &out, "", args[0], 0, 0);
  
  if (ctx.has_error) {
    ant_value_t error = ctx.error;
    result = is_err(error) ? error : js_throw(js, error);
    goto cleanup;
  }

  if (ctx.has_cycle) {
    result = json_cycle_error(js, &ctx);
    goto cleanup;
  }
  
  if (out.oom) {
    result = json_stringify_oom(js);
    goto cleanup;
  }

  if (root == JSON_W_SKIP) {
    result = js_mkundef();
    goto cleanup;
  }

  result = js_mkstr(js, out.buf, out.len);

cleanup:
  free(out.buf);
  free(ctx.stack);
  gc_temp_root_scope_end(&ctx.temp_roots);
  return result;
}

ant_value_t json_stringify_value(ant_t *js, ant_value_t value) {
  ant_value_t args[1] = { value };
  return js_json_stringify(js, args, 1, js_mkundef());
}

void init_json_module(ant_t *js) {
  ant_value_t json_obj = Ant_Object_Create(js);
  
  defmethod(js, json_obj, "parse", 5, Ant_Function_CreateWithArity(js_json_parse, 2));
  defmethod(js, json_obj, "stringify", 9, Ant_Function_CreateWithArity(js_json_stringify, 3));
  
  js_set_tostringtag(js, json_obj, js_mkstr(js, "JSON", 4));
  js_set_global_builtin(js, "JSON", json_obj);
}