#include "internal/ikv_internal.h"
#include "loaders/ikv1.h"
#include "loaders/ikv2.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>

#ifdef IKV_TESTING
typedef struct
{
    int alloc_after;
    int fopen_after;
    int fread_after;
    int fseek_after;
    int ftell_after;
    int fclose_after;
} ikv_test_hooks_t;

static ikv_test_hooks_t ikv_test_hooks = {0};

static bool ikv_test_should_fail(int *remaining_calls)
{
    if (!remaining_calls || *remaining_calls == 0)
        return false;
    if (*remaining_calls > 0)
    {
        (*remaining_calls)--;
        if (*remaining_calls == 0)
            return true;
    }
    return false;
}

void ikv_test_hooks_reset(void)
{
    memset(&ikv_test_hooks, 0, sizeof(ikv_test_hooks));
}

void ikv_test_fail_alloc_after(int remaining_calls) { ikv_test_hooks.alloc_after = remaining_calls; }
void ikv_test_fail_fopen_after(int remaining_calls) { ikv_test_hooks.fopen_after = remaining_calls; }
void ikv_test_fail_fread_after(int remaining_calls) { ikv_test_hooks.fread_after = remaining_calls; }
void ikv_test_fail_fseek_after(int remaining_calls) { ikv_test_hooks.fseek_after = remaining_calls; }
void ikv_test_fail_ftell_after(int remaining_calls) { ikv_test_hooks.ftell_after = remaining_calls; }
void ikv_test_fail_fclose_after(int remaining_calls) { ikv_test_hooks.fclose_after = remaining_calls; }
#endif

void *ikv__malloc(size_t size)
{
#ifdef IKV_TESTING
    if (ikv_test_should_fail(&ikv_test_hooks.alloc_after))
        return NULL;
#endif
    return malloc(size);
}

void *ikv__calloc(size_t count, size_t size)
{
#ifdef IKV_TESTING
    if (ikv_test_should_fail(&ikv_test_hooks.alloc_after))
        return NULL;
#endif
    return calloc(count, size);
}

void *ikv__realloc(void *ptr, size_t size)
{
#ifdef IKV_TESTING
    if (ikv_test_should_fail(&ikv_test_hooks.alloc_after))
        return NULL;
#endif
    return realloc(ptr, size);
}

void ikv__free(void *ptr)
{
    free(ptr);
}

FILE *ikv__fopen(const char *path, const char *mode)
{
#ifdef IKV_TESTING
    if (ikv_test_should_fail(&ikv_test_hooks.fopen_after))
        return NULL;
#endif
    return fopen(path, mode);
}

size_t ikv__fread(void *ptr, size_t size, size_t count, FILE *stream)
{
#ifdef IKV_TESTING
    if (ikv_test_should_fail(&ikv_test_hooks.fread_after))
        return 0u;
#endif
    return fread(ptr, size, count, stream);
}

int ikv__fseek(FILE *stream, long offset, int origin)
{
#ifdef IKV_TESTING
    if (ikv_test_should_fail(&ikv_test_hooks.fseek_after))
        return -1;
#endif
    return fseek(stream, offset, origin);
}

long ikv__ftell(FILE *stream)
{
#ifdef IKV_TESTING
    if (ikv_test_should_fail(&ikv_test_hooks.ftell_after))
        return -1L;
#endif
    return ftell(stream);
}

int ikv__fclose(FILE *stream)
{
#ifdef IKV_TESTING
    if (ikv_test_should_fail(&ikv_test_hooks.fclose_after))
        return EOF;
#endif
    return fclose(stream);
}

static const ikv_loader_t *const ikv_loader_registry[] = {
    &ikv_loader_v1,
    &ikv_loader_v2,
};

static size_t ikv_loader_registry_count(void)
{
    return sizeof(ikv_loader_registry) / sizeof(ikv_loader_registry[0]);
}

static const ikv_loader_t *ikv_find_loader(ikv_version_t version)
{
    size_t index = 0;

    for (index = 0; index < ikv_loader_registry_count(); ++index)
    {
        if (ikv_loader_registry[index]->version == version)
            return ikv_loader_registry[index];
    }

    return NULL;
}

bool ikv__read_file_bytes(const char *path, uint8_t **out_data, size_t *out_size)
{
    FILE *f = NULL;
    long size_long = 0;
    size_t size = 0;
    uint8_t *data = NULL;

    if (!path || !out_data || !out_size)
        return false;

    *out_data = NULL;
    *out_size = 0;

    f = IKV_FOPEN(path, "rb");
    if (!f)
        return false;

    if (IKV_FSEEK(f, 0, SEEK_END) != 0)
    {
        IKV_FCLOSE(f);
        return false;
    }

    size_long = IKV_FTELL(f);
    if (size_long < 0)
    {
        IKV_FCLOSE(f);
        return false;
    }

    if (IKV_FSEEK(f, 0, SEEK_SET) != 0)
    {
        IKV_FCLOSE(f);
        return false;
    }

    size = (size_t)size_long;
    data = (uint8_t *)IKV_MALLOC(size + 1u);
    if (!data)
    {
        IKV_FCLOSE(f);
        return false;
    }

    if (size > 0 && IKV_FREAD(data, 1, size, f) != size)
    {
        IKV_FREE(data);
        IKV_FCLOSE(f);
        return false;
    }

    IKV_FCLOSE(f);
    data[size] = 0;
    *out_data = data;
    *out_size = size;
    return true;
}

static bool read_file_prefix(const char *path, uint8_t *prefix, size_t prefix_capacity, size_t *out_size)
{
    FILE *file = NULL;
    size_t size = 0u;

    if (!path || !prefix || prefix_capacity == 0u || !out_size)
        return false;

    *out_size = 0u;
    prefix[0] = 0u;

    file = IKV_FOPEN(path, "rb");
    if (!file)
        return false;

    size = IKV_FREAD(prefix, 1u, prefix_capacity - 1u, file);
    IKV_FCLOSE(file);
    prefix[size] = 0u;
    *out_size = size;
    return true;
}

static char *ikv_strdup(const char *s)
{
    if (!s)
        return NULL;
    size_t n = strlen(s);
    char *p = (char *)IKV_MALLOC(n + 1);
    if (!p)
        return NULL;
    memcpy(p, s, n + 1);
    return p;
}

static uint32_t fnv1a(const char *s)
{
    uint32_t h = 2166136261u;
    while (s && *s)
    {
        h ^= (uint8_t)*s++;
        h *= 16777619u;
    }
    return h;
}

static ikv_node_t *alloc_node(const char *key)
{
    ikv_node_t *n = (ikv_node_t *)IKV_CALLOC(1, sizeof(*n));
    if (!n)
        return NULL;
    if (key)
    {
        n->key = ikv_strdup(key);
        if (!n->key)
        {
            IKV_FREE(n);
            return NULL;
        }
    }
    return n;
}

static void object_init(ikv_object_t *o, uint32_t buckets)
{
    o->bucket_count = buckets ? buckets : 64;
    o->size = 0;
    o->buckets = (ikv_node_t **)IKV_CALLOC(o->bucket_count, sizeof(ikv_node_t *));
}

static void array_init(ikv_array_t *a, ikv_type_t element_type)
{
    a->element_type = element_type;
    a->count = 0;
    a->items = NULL;
}

static void node_free_payload(ikv_node_t *n)
{
    if (!n)
        return;
    if (n->type == IKV_STRING)
    {
        IKV_FREE(n->value.string);
    }
    else if (n->type == IKV_OBJECT)
    {
        for (uint32_t i = 0; i < n->value.object.bucket_count; i++)
        {
            ikv_node_t *c = n->value.object.buckets[i];
            while (c)
            {
                ikv_node_t *next = c->next;
                ikv_free(c);
                c = next;
            }
        }
        IKV_FREE(n->value.object.buckets);
    }
    else if (n->type == IKV_ARRAY)
    {
        for (uint32_t i = 0; i < n->value.array.count; i++)
            ikv_free(n->value.array.items[i]);
        IKV_FREE(n->value.array.items);
    }

    if (n->lazy_state)
    {
        n->lazy_state->destroy(n->lazy_state);
        n->lazy_state = NULL;
    }
}

void ikv_free(ikv_node_t *n)
{
    if (!n)
        return;
    IKV_FREE(n->key);
    node_free_payload(n);
    IKV_FREE(n);
}

static void ikv_replace_node_contents(ikv_node_t *dst, ikv_node_t *src)
{
    if (!dst || !src)
        return;

    IKV_FREE(dst->key);
    node_free_payload(dst);

    dst->key = src->key;
    dst->type = src->type;
    dst->lazy_state = src->lazy_state;
    dst->value = src->value;
    dst->next = NULL;

    src->key = NULL;
    src->type = IKV_NULL;
    src->lazy_state = NULL;
    memset(&src->value, 0, sizeof(src->value));
    src->next = NULL;
}

bool ikv_refresh_from_path(ikv_node_t *root_node, const char *path)
{
    ikv_node_t *updated = NULL;

    if (!root_node || !path)
        return false;

    updated = ikv_parse_file(path);
    if (!updated)
        return false;

    ikv_replace_node_contents(root_node, updated);
    IKV_FREE(updated);
    return true;
}

const char *ikv_node_key(const ikv_node_t *node)
{
    return (node && node->key) ? node->key : "";
}

ikv_type_t ikv_node_type(const ikv_node_t *node)
{
    return node ? node->type : IKV_NULL;
}

uint32_t ikv_object_size(const ikv_node_t *object_node)
{
    if (!object_node || object_node->type != IKV_OBJECT)
        return 0u;
    return object_node->value.object.size;
}

uint32_t ikv_array_size(const ikv_node_t *array_node)
{
    if (!array_node || array_node->type != IKV_ARRAY)
        return 0u;
    return array_node->value.array.count;
}

ikv_type_t ikv_array_element_type(const ikv_node_t *array_node)
{
    if (!array_node || array_node->type != IKV_ARRAY)
        return IKV_NULL;
    return array_node->value.array.element_type;
}

ikv_node_t *ikv_create_object(const char *key)
{
    ikv_node_t *n = alloc_node(key);
    if (!n)
        return NULL;
    n->type = IKV_OBJECT;
    object_init(&n->value.object, 64);
    if (!n->value.object.buckets)
    {
        ikv_free(n);
        return NULL;
    }
    return n;
}

ikv_node_t *ikv_create_array(const char *key, ikv_type_t element_type)
{
    ikv_node_t *n = alloc_node(key);
    if (!n)
        return NULL;
    n->type = IKV_ARRAY;
    array_init(&n->value.array, element_type);
    return n;
}

static ikv_node_t *object_find_node(const ikv_object_t *o, const char *key, ikv_node_t **out_prev, uint32_t *out_bucket)
{
    if (out_prev)
        *out_prev = NULL;
    if (out_bucket)
        *out_bucket = 0;
    if (!o || !o->buckets || !key)
        return NULL;

    uint32_t b = fnv1a(key) % o->bucket_count;
    if (out_bucket)
        *out_bucket = b;

    ikv_node_t *prev = NULL;
    ikv_node_t *cur = o->buckets[b];
    while (cur)
    {
        if (cur->key && strcmp(cur->key, key) == 0)
        {
            if (out_prev)
                *out_prev = prev;
            return cur;
        }
        prev = cur;
        cur = cur->next;
    }
    if (out_prev)
        *out_prev = prev;
    return NULL;
}

static void object_rehash(ikv_object_t *o, uint32_t new_bucket_count)
{
    ikv_node_t **new_buckets = (ikv_node_t **)IKV_CALLOC(new_bucket_count, sizeof(ikv_node_t *));
    if (!new_buckets)
        return;

    for (uint32_t i = 0; i < o->bucket_count; i++)
    {
        ikv_node_t *c = o->buckets[i];
        while (c)
        {
            ikv_node_t *next = c->next;
            uint32_t b = fnv1a(c->key) % new_bucket_count;
            c->next = new_buckets[b];
            new_buckets[b] = c;
            c = next;
        }
    }

    IKV_FREE(o->buckets);
    o->buckets = new_buckets;
    o->bucket_count = new_bucket_count;
}

static void object_maybe_grow(ikv_object_t *o)
{
    if (!o || o->bucket_count == 0)
        return;
    if (o->size * 4 >= o->bucket_count * 3)
        object_rehash(o, o->bucket_count * 2);
}

static void object_put_node(ikv_object_t *o, ikv_node_t *n)
{
    if (!o || !n || !n->key)
        return;

    object_maybe_grow(o);

    uint32_t b = fnv1a(n->key) % o->bucket_count;
    n->next = o->buckets[b];
    o->buckets[b] = n;
    o->size++;
}

static void object_attach_loaded_node(ikv_object_t *o, ikv_node_t *n)
{
    uint32_t b = 0;

    if (!o || !n || !n->key)
        return;

    object_maybe_grow(o);
    b = fnv1a(n->key) % o->bucket_count;
    n->next = o->buckets[b];
    o->buckets[b] = n;
}

static void object_set_node(ikv_object_t *o, ikv_node_t *n)
{
    if (!o || !n || !n->key)
    {
        ikv_free(n);
        return;
    }

    uint32_t bucket = 0;
    ikv_node_t *prev = NULL;
    ikv_node_t *found = object_find_node(o, n->key, &prev, &bucket);

    if (found)
    {
        if (prev)
            prev->next = found->next;
        else
            o->buckets[bucket] = found->next;
        o->size--;
        ikv_free(found);
    }

    object_put_node(o, n);
}

void ikv_object_set_int(ikv_node_t *obj, const char *key, int64_t v)
{
    if (!obj || obj->type != IKV_OBJECT || !key)
        return;
    ikv_node_t *n = alloc_node(key);
    if (!n)
        return;
    n->type = IKV_INT;
    n->value.i = v;
    object_set_node(&obj->value.object, n);
}

void ikv_object_set_bool(ikv_node_t *obj, const char *key, bool v)
{
    if (!obj || obj->type != IKV_OBJECT || !key)
        return;
    ikv_node_t *n = alloc_node(key);
    if (!n)
        return;
    n->type = IKV_BOOL;
    n->value.b = v;
    object_set_node(&obj->value.object, n);
}

void ikv_object_set_float(ikv_node_t *obj, const char *key, double v)
{
    if (!obj || obj->type != IKV_OBJECT || !key)
        return;
    ikv_node_t *n = alloc_node(key);
    if (!n)
        return;
    n->type = IKV_FLOAT;
    n->value.f = v;
    object_set_node(&obj->value.object, n);
}

void ikv_object_set_string(ikv_node_t *obj, const char *key, const char *v)
{
    if (!obj || obj->type != IKV_OBJECT || !key)
        return;
    ikv_node_t *n = alloc_node(key);
    if (!n)
        return;
    n->type = IKV_STRING;
    n->value.string = ikv_strdup(v ? v : "");
    if (!n->value.string)
    {
        ikv_free(n);
        return;
    }
    object_set_node(&obj->value.object, n);
}

ikv_node_t *ikv_object_add_object(ikv_node_t *obj, const char *key)
{
    if (!obj || obj->type != IKV_OBJECT || !key)
        return NULL;
    ikv_node_t *n = ikv_create_object(key);
    if (!n)
        return NULL;
    object_set_node(&obj->value.object, n);
    return n;
}

ikv_node_t *ikv_object_add_array(ikv_node_t *obj, const char *key, ikv_type_t t)
{
    if (!obj || obj->type != IKV_OBJECT || !key)
        return NULL;
    ikv_node_t *n = ikv_create_array(key, t);
    if (!n)
        return NULL;
    object_set_node(&obj->value.object, n);
    return n;
}

static void array_push_node(ikv_array_t *a, ikv_node_t *n)
{
    ikv_node_t **p = (ikv_node_t **)IKV_REALLOC(a->items, sizeof(ikv_node_t *) * (a->count + 1));
    if (!p)
    {
        ikv_free(n);
        return;
    }
    a->items = p;
    a->items[a->count++] = n;
}

static bool array_type_ok(ikv_array_t *a, ikv_type_t t)
{
    if (!a)
        return false;
    if (a->element_type == IKV_NULL)
        return true;
    return a->element_type == t;
}

void ikv_array_add_int(ikv_node_t *arr, int64_t v)
{
    if (!arr || arr->type != IKV_ARRAY)
        return;
    if (!array_type_ok(&arr->value.array, IKV_INT))
        return;
    ikv_node_t *n = alloc_node(NULL);
    if (!n)
        return;
    n->type = IKV_INT;
    n->value.i = v;
    array_push_node(&arr->value.array, n);
}

void ikv_array_add_bool(ikv_node_t *arr, bool v)
{
    if (!arr || arr->type != IKV_ARRAY)
        return;
    if (!array_type_ok(&arr->value.array, IKV_BOOL))
        return;
    ikv_node_t *n = alloc_node(NULL);
    if (!n)
        return;
    n->type = IKV_BOOL;
    n->value.b = v;
    array_push_node(&arr->value.array, n);
}

void ikv_array_add_float(ikv_node_t *arr, double v)
{
    if (!arr || arr->type != IKV_ARRAY)
        return;
    if (!array_type_ok(&arr->value.array, IKV_FLOAT))
        return;
    ikv_node_t *n = alloc_node(NULL);
    if (!n)
        return;
    n->type = IKV_FLOAT;
    n->value.f = v;
    array_push_node(&arr->value.array, n);
}

void ikv_array_add_string(ikv_node_t *arr, const char *v)
{
    if (!arr || arr->type != IKV_ARRAY)
        return;
    if (!array_type_ok(&arr->value.array, IKV_STRING))
        return;
    ikv_node_t *n = alloc_node(NULL);
    if (!n)
        return;
    n->type = IKV_STRING;
    n->value.string = ikv_strdup(v ? v : "");
    if (!n->value.string)
    {
        ikv_free(n);
        return;
    }
    array_push_node(&arr->value.array, n);
}

ikv_node_t *ikv_array_add_object(ikv_node_t *arr)
{
    if (!arr || arr->type != IKV_ARRAY)
        return NULL;
    if (!array_type_ok(&arr->value.array, IKV_OBJECT))
        return NULL;
    ikv_node_t *n = ikv_create_object(NULL);
    if (!n)
        return NULL;
    array_push_node(&arr->value.array, n);
    return n;
}

ikv_node_t *ikv_object_get(const ikv_node_t *obj, const char *key)
{
    ikv_node_t *n = NULL;
    ikv_node_t *loaded = NULL;
    ikv_node_t *mutable_obj = (ikv_node_t *)obj;

    if (!obj || obj->type != IKV_OBJECT || !key)
        return NULL;

    if (obj->value.object.bucket_count == 0)
        return NULL;

    {
        uint32_t b = fnv1a(key) % obj->value.object.bucket_count;
        n = obj->value.object.buckets[b];
    }

    while (n)
    {
        if (n->key && strcmp(n->key, key) == 0)
            return n;
        n = n->next;
    }

    if (!mutable_obj->lazy_state || !mutable_obj->lazy_state->load_object_key)
        return NULL;

    loaded = mutable_obj->lazy_state->load_object_key(mutable_obj->lazy_state, mutable_obj, key);
    if (!loaded)
        return NULL;

    if (!loaded->key)
    {
        loaded->key = ikv_strdup(key);
        if (!loaded->key)
        {
            ikv_free(loaded);
            return NULL;
        }
    }

    object_attach_loaded_node(&mutable_obj->value.object, loaded);
    return loaded;
}

ikv_node_t *ikv_array_get(const ikv_node_t *arr, uint32_t index)
{
    if (!arr || arr->type != IKV_ARRAY)
        return NULL;
    if (index >= arr->value.array.count)
        return NULL;
    return arr->value.array.items[index];
}

const char *ikv_as_string(const ikv_node_t *n) { return (n && n->type == IKV_STRING && n->value.string) ? n->value.string : ""; }
int64_t ikv_as_int(const ikv_node_t *n) { return (n && n->type == IKV_INT) ? n->value.i : 0; }
double ikv_as_float(const ikv_node_t *n) { return (n && n->type == IKV_FLOAT) ? n->value.f : 0.0; }
bool ikv_as_bool(const ikv_node_t *n) { return (n && n->type == IKV_BOOL) ? n->value.b : false; }

static void write_indent(FILE *f, int indent)
{
    for (int i = 0; i < indent; i++)
        fputc(' ', f);
}

static void write_escaped_string(FILE *f, const char *s)
{
    fputc('"', f);
    for (const char *p = s ? s : ""; *p; p++)
    {
        unsigned char c = (unsigned char)*p;
        if (c == '\\')
        {
            fputs("\\\\", f);
        }
        else if (c == '"')
        {
            fputs("\\\"", f);
        }
        else if (c == '\n')
        {
            fputs("\\n", f);
        }
        else if (c == '\r')
        {
            fputs("\\r", f);
        }
        else if (c == '\t')
        {
            fputs("\\t", f);
        }
        else
        {
            fputc(c, f);
        }
    }
    fputc('"', f);
}

static void write_node(FILE *f, const ikv_node_t *n, int indent);

static void write_value(FILE *f, const ikv_node_t *n, int indent)
{
    switch (n->type)
    {
    case IKV_NULL:
        fputs("null", f);
        break;
    case IKV_STRING:
        write_escaped_string(f, n->value.string ? n->value.string : "");
        break;
    case IKV_INT:
        fprintf(f, "%lld", (long long)n->value.i);
        break;
    case IKV_BOOL:
        fputs(n->value.b ? "true" : "false", f);
        break;
    case IKV_FLOAT:
    {
        char buf[64];
        snprintf(buf, sizeof(buf), "%.17g", n->value.f);
        fputs(buf, f);
    }
    break;
    case IKV_OBJECT:
    {
        fputs("{\n", f);
        for (uint32_t i = 0; i < n->value.object.bucket_count; i++)
        {
            for (ikv_node_t *c = n->value.object.buckets[i]; c; c = c->next)
                write_node(f, c, indent + 4);
        }
        write_indent(f, indent);
        fputc('}', f);
    }
    break;
    case IKV_ARRAY:
    {
        fputs("[\n", f);
        for (uint32_t i = 0; i < n->value.array.count; i++)
        {
            write_indent(f, indent + 4);
            write_value(f, n->value.array.items[i], indent + 4);
            fputc('\n', f);
        }
        write_indent(f, indent);
        fputc(']', f);
    }
    break;
    default:
        break;
    }
}

static void write_node(FILE *f, const ikv_node_t *n, int indent)
{
    write_indent(f, indent);
    if (n->key)
    {
        write_escaped_string(f, n->key);
        fputc(' ', f);
    }
    write_value(f, n, indent);
    fputc('\n', f);
}

bool ikv__write_text_file_version(const char *path, const ikv_node_t *root, uint32_t version)
{
    if (!path || !root)
        return false;

    FILE *f = IKV_FOPEN(path, "wb");
    if (!f)
        return false;

    if (root->type != IKV_OBJECT)
    {
        write_value(f, root, 0);
        fputc('\n', f);
        IKV_FCLOSE(f);
        return true;
    }

    fprintf(f, "ikv%u ", version);
    write_escaped_string(f, (root->key && root->key[0]) ? root->key : "root");
    fputc('\n', f);

    fputs("{\n", f);
    for (uint32_t i = 0; i < root->value.object.bucket_count; i++)
    {
        for (ikv_node_t *c = root->value.object.buckets[i]; c; c = c->next)
            write_node(f, c, 4);
    }
    fputs("}\n", f);

    IKV_FCLOSE(f);
    return true;
}

typedef enum
{
    T_EOF,
    T_LBRACE,
    T_RBRACE,
    T_LBRACK,
    T_RBRACK,
    T_COMMA,
    T_STRING,
    T_WORD
} tok_type;

typedef struct
{
    tok_type type;
    const char *start;
    size_t len;
} token;

typedef struct
{
    const char *p;
} lexer;

static const char *lex_skip_ws(const char *p)
{
    while (*p)
    {
        if (isspace((unsigned char)*p))
        {
            p++;
            continue;
        }
        if (p[0] == '/' && p[1] == '/')
        {
            p += 2;
            while (*p && *p != '\n')
                p++;
            continue;
        }
        if (p[0] == '#')
        {
            p += 1;
            while (*p && *p != '\n')
                p++;
            continue;
        }
        break;
    }
    return p;
}

static token lex_next(lexer *l)
{
    token t;
    t.type = T_EOF;
    t.start = l->p;
    t.len = 0;

    l->p = lex_skip_ws(l->p);
    const char *p = l->p;
    if (!*p)
    {
        t.type = T_EOF;
        return t;
    }

    if (*p == '{')
    {
        l->p = p + 1;
        t.type = T_LBRACE;
        return t;
    }
    if (*p == '}')
    {
        l->p = p + 1;
        t.type = T_RBRACE;
        return t;
    }
    if (*p == '[')
    {
        l->p = p + 1;
        t.type = T_LBRACK;
        return t;
    }
    if (*p == ']')
    {
        l->p = p + 1;
        t.type = T_RBRACK;
        return t;
    }
    if (*p == ',')
    {
        l->p = p + 1;
        t.type = T_COMMA;
        return t;
    }

    if (*p == '"')
    {
        p++;
        const char *s = p;
        while (*p)
        {
            if (*p == '\\' && p[1])
            {
                p += 2;
                continue;
            }
            if (*p == '"')
                break;
            p++;
        }
        if (*p != '"')
        {
            l->p = p;
            t.type = T_EOF;
            return t;
        }
        t.type = T_STRING;
        t.start = s;
        t.len = (size_t)(p - s);
        l->p = p + 1;
        return t;
    }

    const char *s = p;
    while (*p && !isspace((unsigned char)*p) && *p != '{' && *p != '}' && *p != '[' && *p != ']' && *p != ',')
        p++;
    t.type = T_WORD;
    t.start = s;
    t.len = (size_t)(p - s);
    l->p = p;
    return t;
}

static char *unescape_string(const char *s, size_t len)
{
    char *out = (char *)IKV_MALLOC(len + 1);
    if (!out)
        return NULL;
    size_t w = 0;
    for (size_t i = 0; i < len; i++)
    {
        char c = s[i];
        if (c == '\\' && i + 1 < len)
        {
            char n = s[i + 1];
            if (n == 'n')
            {
                out[w++] = '\n';
                i++;
                continue;
            }
            if (n == 'r')
            {
                out[w++] = '\r';
                i++;
                continue;
            }
            if (n == 't')
            {
                out[w++] = '\t';
                i++;
                continue;
            }
            if (n == '\\')
            {
                out[w++] = '\\';
                i++;
                continue;
            }
            if (n == '"')
            {
                out[w++] = '"';
                i++;
                continue;
            }
        }
        out[w++] = c;
    }
    out[w] = 0;
    return out;
}

static char *token_to_cstr(const token *t)
{
    char *s = (char *)IKV_MALLOC(t->len + 1);
    if (!s)
        return NULL;
    memcpy(s, t->start, t->len);
    s[t->len] = 0;
    return s;
}

static ikv_node_t *parse_value_lex(lexer *l);

static ikv_node_t *parse_array_lex(lexer *l)
{
    ikv_node_t *arr = ikv_create_array(NULL, IKV_NULL);
    if (!arr)
        return NULL;

    for (;;)
    {
        const char *save = l->p;
        token t = lex_next(l);
        if (t.type == T_RBRACK)
            break;
        if (t.type == T_EOF)
        {
            ikv_free(arr);
            return NULL;
        }
        if (t.type == T_COMMA)
            continue;
        l->p = save;

        ikv_node_t *v = parse_value_lex(l);
        if (!v)
        {
            ikv_free(arr);
            return NULL;
        }

        if (arr->value.array.element_type == IKV_NULL && v->type != IKV_NULL)
            arr->value.array.element_type = v->type;

        if (arr->value.array.element_type != IKV_NULL && v->type != IKV_NULL && v->type != arr->value.array.element_type)
            arr->value.array.element_type = IKV_NULL;

        array_push_node(&arr->value.array, v);

        save = l->p;
        t = lex_next(l);
        if (t.type == T_RBRACK)
            break;
        if (t.type == T_EOF)
        {
            ikv_free(arr);
            return NULL;
        }
        if (t.type != T_COMMA)
            l->p = save;
    }

    return arr;
}

static ikv_node_t *parse_object_lex(lexer *l)
{
    ikv_node_t *obj = ikv_create_object(NULL);
    if (!obj)
        return NULL;

    for (;;)
    {
        token k = lex_next(l);
        if (k.type == T_RBRACE)
            break;
        if (k.type == T_EOF)
        {
            ikv_free(obj);
            return NULL;
        }
        if (k.type == T_COMMA)
            continue;
        if (k.type != T_STRING)
        {
            ikv_free(obj);
            return NULL;
        }

        char *key = unescape_string(k.start, k.len);
        if (!key)
        {
            ikv_free(obj);
            return NULL;
        }

        ikv_node_t *val = parse_value_lex(l);
        if (!val)
        {
            IKV_FREE(key);
            ikv_free(obj);
            return NULL;
        }

        IKV_FREE(val->key);
        val->key = key;
        object_set_node(&obj->value.object, val);

        const char *save = l->p;
        token t = lex_next(l);
        if (t.type == T_RBRACE)
            break;
        if (t.type == T_EOF)
        {
            ikv_free(obj);
            return NULL;
        }
        if (t.type != T_COMMA)
            l->p = save;
    }

    return obj;
}

static ikv_node_t *parse_value_lex(lexer *l)
{
    token t = lex_next(l);

    if (t.type == T_LBRACE)
        return parse_object_lex(l);
    if (t.type == T_LBRACK)
        return parse_array_lex(l);

    if (t.type == T_STRING)
    {
        ikv_node_t *n = alloc_node(NULL);
        if (!n)
            return NULL;
        n->type = IKV_STRING;
        n->value.string = unescape_string(t.start, t.len);
        if (!n->value.string)
        {
            ikv_free(n);
            return NULL;
        }
        return n;
    }

    if (t.type == T_WORD)
    {
        char *w = token_to_cstr(&t);
        if (!w)
            return NULL;

        ikv_node_t *n = alloc_node(NULL);
        if (!n)
        {
            IKV_FREE(w);
            return NULL;
        }

        if (strcmp(w, "true") == 0)
        {
            n->type = IKV_BOOL;
            n->value.b = true;
            IKV_FREE(w);
            return n;
        }
        if (strcmp(w, "false") == 0)
        {
            n->type = IKV_BOOL;
            n->value.b = false;
            IKV_FREE(w);
            return n;
        }
        if (strcmp(w, "null") == 0)
        {
            n->type = IKV_NULL;
            IKV_FREE(w);
            return n;
        }

        char *endp = NULL;
        double df = strtod(w, &endp);
        if (endp && *endp == 0)
        {
            if (strchr(w, '.') || strchr(w, 'e') || strchr(w, 'E'))
            {
                n->type = IKV_FLOAT;
                n->value.f = df;
                IKV_FREE(w);
                return n;
            }
            else
            {
                long long di = strtoll(w, &endp, 10);
                if (endp && *endp == 0)
                {
                    n->type = IKV_INT;
                    n->value.i = (int64_t)di;
                    IKV_FREE(w);
                    return n;
                }
            }
        }

        n->type = IKV_STRING;
        n->value.string = w;
        return n;
    }

    return NULL;
}

ikv_node_t *ikv__parse_text_string_version(const char *src, uint32_t version)
{
    if (!src)
        return NULL;

    lexer l;
    l.p = src;

    const char *save0 = l.p;
    token t0 = lex_next(&l);

    if (t0.type == T_WORD)
    {
        char *w0 = token_to_cstr(&t0);
        if (!w0)
            return NULL;

        char version_tag[16];
        snprintf(version_tag, sizeof(version_tag), "ikv%u", version);

        if (strcmp(w0, version_tag) == 0)
        {
            IKV_FREE(w0);

            token tn = lex_next(&l);
            if (tn.type != T_STRING && tn.type != T_WORD)
                return NULL;

            char *name = (tn.type == T_STRING) ? unescape_string(tn.start, tn.len) : token_to_cstr(&tn);
            if (!name)
                return NULL;

            token tb = lex_next(&l);
            if (tb.type != T_LBRACE)
            {
                IKV_FREE(name);
                return NULL;
            }

            ikv_node_t *obj = parse_object_lex(&l);
            if (!obj)
            {
                IKV_FREE(name);
                return NULL;
            }

            IKV_FREE(obj->key);
            obj->key = name;
            return obj;
        }

        IKV_FREE(w0);
        l.p = save0;
    }
    else if (t0.type == T_LBRACE)
    {
        return parse_object_lex(&l);
    }
    else
    {
        l.p = save0;
    }

    ikv_node_t *root = ikv_create_object(NULL);
    if (!root)
        return NULL;

    for (;;)
    {
        const char *s2 = l.p;
        token k = lex_next(&l);
        if (k.type == T_EOF)
            break;
        if (k.type == T_COMMA)
            continue;
        if (k.type != T_STRING)
        {
            ikv_free(root);
            return NULL;
        }

        char *key = unescape_string(k.start, k.len);
        if (!key)
        {
            ikv_free(root);
            return NULL;
        }

        ikv_node_t *val = parse_value_lex(&l);
        if (!val)
        {
            IKV_FREE(key);
            ikv_free(root);
            return NULL;
        }

        IKV_FREE(val->key);
        val->key = key;
        object_set_node(&root->value.object, val);

        s2 = l.p;
        token sep = lex_next(&l);
        if (sep.type == T_EOF)
            break;
        if (sep.type != T_COMMA)
            l.p = s2;
    }

    return root;
}

ikv_node_t *ikv__parse_text_file_version(const char *path, uint32_t version)
{
    if (!path)
        return NULL;

    uint8_t *bytes = NULL;
    size_t bytes_n = 0u;
    char *buf = NULL;
    ikv_node_t *root = NULL;

    if (!ikv__read_file_bytes(path, &bytes, &bytes_n) || !bytes)
        return NULL;

    buf = (char *)IKV_MALLOC(bytes_n + 1u);
    if (!buf)
    {
        IKV_FREE(bytes);
        return NULL;
    }
    if (bytes_n > 0u)
        memcpy(buf, bytes, bytes_n);
    buf[bytes_n] = 0;
    IKV_FREE(bytes);

    root = ikv__parse_text_string_version(buf, version);
    IKV_FREE(buf);
    return root;
}

typedef struct
{
    void *ctx;
    bool ok;
    void (*write_bytes_fn)(void *ctx, bool *ok, const void *p, size_t n);
} bw_t;

typedef struct
{
    uint8_t *data;
    size_t size;
    size_t cap;
} bw_mem_t;

static bool bw_mem_reserve(bw_mem_t *m, size_t add)
{
    if (!m)
        return false;
    if (add > SIZE_MAX - m->size)
        return false;
    size_t need = m->size + add;
    if (need <= m->cap)
        return true;

    size_t new_cap = (m->cap > 0u) ? m->cap : 256u;
    while (new_cap < need)
    {
        if (new_cap > (SIZE_MAX / 2u))
        {
            new_cap = need;
            break;
        }
        new_cap *= 2u;
    }

    uint8_t *p = (uint8_t *)IKV_REALLOC(m->data, new_cap);
    if (!p)
        return false;
    m->data = p;
    m->cap = new_cap;
    return true;
}

static void bw_mem_write_bytes(void *ctx, bool *ok, const void *p, size_t n)
{
    bw_mem_t *m = (bw_mem_t *)ctx;
    if (!m || !ok || !*ok)
        return;
    if (n == 0u)
        return;
    if (!bw_mem_reserve(m, n))
    {
        *ok = false;
        return;
    }
    memcpy(m->data + m->size, p, n);
    m->size += n;
}

static void bw_bytes(bw_t *w, const void *p, size_t n)
{
    if (!w || !w->ok || !w->write_bytes_fn)
        return;
    w->write_bytes_fn(w->ctx, &w->ok, p, n);
}

static void bw_u8(bw_t *w, uint8_t v) { bw_bytes(w, &v, 1u); }

static void bw_u32le(bw_t *w, uint32_t v)
{
    uint8_t b[4];
    b[0] = (uint8_t)(v & 255u);
    b[1] = (uint8_t)((v >> 8) & 255u);
    b[2] = (uint8_t)((v >> 16) & 255u);
    b[3] = (uint8_t)((v >> 24) & 255u);
    bw_bytes(w, b, sizeof(b));
}

static void bw_u64le(bw_t *w, uint64_t v)
{
    uint8_t b[8];
    b[0] = (uint8_t)(v & 255u);
    b[1] = (uint8_t)((v >> 8) & 255u);
    b[2] = (uint8_t)((v >> 16) & 255u);
    b[3] = (uint8_t)((v >> 24) & 255u);
    b[4] = (uint8_t)((v >> 32) & 255u);
    b[5] = (uint8_t)((v >> 40) & 255u);
    b[6] = (uint8_t)((v >> 48) & 255u);
    b[7] = (uint8_t)((v >> 56) & 255u);
    bw_bytes(w, b, sizeof(b));
}

static void bw_varu64(bw_t *w, uint64_t v)
{
    while (v >= 0x80u)
    {
        bw_u8(w, (uint8_t)((v & 0x7Fu) | 0x80u));
        v >>= 7;
    }
    bw_u8(w, (uint8_t)v);
}

static void bw_varu32(bw_t *w, uint32_t v) { bw_varu64(w, (uint64_t)v); }

static uint64_t bw_zz64(int64_t v)
{
    return (uint64_t)((v << 1) ^ (v >> 63));
}

static void bw_vari64(bw_t *w, int64_t v) { bw_varu64(w, bw_zz64(v)); }

static void bw_str(bw_t *w, const char *s)
{
    const char *p = s ? s : "";
    size_t n = strlen(p);
    if (n > 0xFFFFFFFFu)
        n = 0xFFFFFFFFu;
    bw_varu32(w, (uint32_t)n);
    bw_bytes(w, p, n);
}

static uint32_t bw_object_count(const ikv_node_t *obj)
{
    uint32_t c = 0;
    for (uint32_t i = 0; i < obj->value.object.bucket_count; i++)
        for (ikv_node_t *n = obj->value.object.buckets[i]; n; n = n->next)
            c++;
    return c;
}

static void bw_val_payload(bw_t *w, const ikv_node_t *n);

static void bw_node(bw_t *w, const ikv_node_t *n)
{
    bw_u8(w, (uint8_t)n->type);
    bw_val_payload(w, n);
}

static void bw_fixed_payload(bw_t *w, const ikv_node_t *n, ikv_type_t t)
{
    if (!n)
    {
        if (t == IKV_STRING)
            bw_str(w, "");
        else if (t == IKV_INT)
            bw_vari64(w, 0);
        else if (t == IKV_BOOL)
            bw_u8(w, 0);
        else if (t == IKV_FLOAT)
        {
            union
            {
                double d;
                uint64_t u;
            } x;
            x.d = 0.0;
            bw_u64le(w, x.u);
        }
        return;
    }

    if (t == IKV_STRING)
    {
        bw_str(w, (n->type == IKV_STRING) ? n->value.string : "");
        return;
    }
    if (t == IKV_INT)
    {
        bw_vari64(w, (n->type == IKV_INT) ? n->value.i : 0);
        return;
    }
    if (t == IKV_BOOL)
    {
        bw_u8(w, (uint8_t)((n->type == IKV_BOOL) ? (n->value.b ? 1 : 0) : 0));
        return;
    }
    if (t == IKV_FLOAT)
    {
        union
        {
            double d;
            uint64_t u;
        } x;
        x.d = (n->type == IKV_FLOAT) ? n->value.f : 0.0;
        bw_u64le(w, x.u);
        return;
    }
    bw_node(w, n);
}

static void bw_val_payload(bw_t *w, const ikv_node_t *n)
{
    switch (n->type)
    {
    case IKV_NULL:
        break;
    case IKV_BOOL:
        bw_u8(w, (uint8_t)(n->value.b ? 1 : 0));
        break;
    case IKV_INT:
        bw_vari64(w, n->value.i);
        break;
    case IKV_FLOAT:
    {
        union
        {
            double d;
            uint64_t u;
        } x;
        x.d = n->value.f;
        bw_u64le(w, x.u);
    }
    break;
    case IKV_STRING:
        bw_str(w, n->value.string);
        break;
    case IKV_OBJECT:
    {
        uint32_t cnt = bw_object_count(n);
        bw_varu32(w, cnt);
        for (uint32_t i = 0; i < n->value.object.bucket_count; i++)
        {
            for (ikv_node_t *c = n->value.object.buckets[i]; c; c = c->next)
            {
                bw_str(w, c->key ? c->key : "");
                bw_node(w, c);
            }
        }
    }
    break;
    case IKV_ARRAY:
    {
        bw_u8(w, (uint8_t)n->value.array.element_type);
        bw_varu32(w, n->value.array.count);
        ikv_type_t et = n->value.array.element_type;
        if (et == IKV_NULL)
        {
            for (uint32_t i = 0; i < n->value.array.count; i++)
                bw_node(w, n->value.array.items[i]);
        }
        else
        {
            for (uint32_t i = 0; i < n->value.array.count; i++)
                bw_fixed_payload(w, n->value.array.items[i], et);
        }
    }
    break;
    default:
        break;
    }
}

bool ikv__write_binary_memory_version(const ikv_node_t *root, uint8_t **out_data, uint32_t *out_size, uint32_t version)
{
    if (!root || !out_data || !out_size)
        return false;

    *out_data = NULL;
    *out_size = 0u;

    bw_mem_t mem = {0};
    bw_t w = {0};
    w.ctx = &mem;
    w.ok = true;
    w.write_bytes_fn = bw_mem_write_bytes;

    uint8_t magic[4];
    magic[0] = (uint8_t)'i';
    magic[1] = (uint8_t)'K';
    magic[2] = (uint8_t)'v';
    magic[3] = (uint8_t)('0' + (uint8_t)version);
    bw_bytes(&w, magic, sizeof(magic));

    bw_u8(&w, (uint8_t)'b');
    bw_u32le(&w, version);
    bw_str(&w, (root->key && root->key[0]) ? root->key : "root");
    bw_node(&w, root);

    if (!w.ok || mem.size == 0u || mem.size > 0xFFFFFFFFu)
    {
        IKV_FREE(mem.data);
        return false;
    }

    *out_data = mem.data;
    *out_size = (uint32_t)mem.size;
    return true;
}

bool ikv__write_binary_node_memory(const ikv_node_t *node, uint8_t **out_data, uint32_t *out_size)
{
    bw_mem_t mem = {0};
    bw_t w = {0};

    if (!node || !out_data || !out_size)
        return false;

    *out_data = NULL;
    *out_size = 0u;

    w.ctx = &mem;
    w.ok = true;
    w.write_bytes_fn = bw_mem_write_bytes;
    bw_node(&w, node);

    if (!w.ok || mem.size == 0u || mem.size > 0xFFFFFFFFu)
    {
        IKV_FREE(mem.data);
        return false;
    }

    *out_data = mem.data;
    *out_size = (uint32_t)mem.size;
    return true;
}

bool ikv__write_binary_node_append(const ikv_node_t *node, uint8_t **data, size_t *size, size_t *capacity)
{
    bw_mem_t mem = {0};
    bw_t w = {0};
    size_t start_size = 0u;

    if (!node || !data || !size || !capacity)
        return false;

    mem.data = *data;
    mem.size = *size;
    mem.cap = *capacity;
    start_size = mem.size;
    w.ctx = &mem;
    w.ok = true;
    w.write_bytes_fn = bw_mem_write_bytes;
    bw_node(&w, node);

    if (!w.ok || mem.size == start_size || mem.size > 0xFFFFFFFFu)
        return false;

    *data = mem.data;
    *size = mem.size;
    *capacity = mem.cap;
    return true;
}

bool ikv__write_binary_file_version(const char *path, const ikv_node_t *root, uint32_t version)
{
    if (!path || !root)
        return false;

    uint8_t *data = NULL;
    uint32_t size = 0u;
    if (!ikv__write_binary_memory_version(root, &data, &size, version) || !data || size == 0u)
        return false;

    FILE *f = IKV_FOPEN(path, "wb");
    if (!f)
    {
        IKV_FREE(data);
        return false;
    }

    bool ok = (fwrite(data, 1, size, f) == size);
    if (IKV_FCLOSE(f) != 0)
        ok = false;
    IKV_FREE(data);
    return ok;
}

typedef struct
{
    const uint8_t *p;
    const uint8_t *e;
} br_t;

static bool br_need(br_t *r, size_t n) { return r && r->p && r->e && (size_t)(r->e - r->p) >= n; }

static bool br_u8(br_t *r, uint8_t *out)
{
    if (!br_need(r, 1))
        return false;
    *out = r->p[0];
    r->p += 1;
    return true;
}

static bool br_u32le(br_t *r, uint32_t *out)
{
    if (!br_need(r, 4))
        return false;
    const uint8_t *p = r->p;
    *out = (uint32_t)p[0] | ((uint32_t)p[1] << 8) | ((uint32_t)p[2] << 16) | ((uint32_t)p[3] << 24);
    r->p += 4;
    return true;
}

static bool br_u64le(br_t *r, uint64_t *out)
{
    if (!br_need(r, 8))
        return false;
    const uint8_t *p = r->p;
    *out = (uint64_t)p[0] |
           ((uint64_t)p[1] << 8) |
           ((uint64_t)p[2] << 16) |
           ((uint64_t)p[3] << 24) |
           ((uint64_t)p[4] << 32) |
           ((uint64_t)p[5] << 40) |
           ((uint64_t)p[6] << 48) |
           ((uint64_t)p[7] << 56);
    r->p += 8;
    return true;
}

static bool br_varu64(br_t *r, uint64_t *out)
{
    uint64_t v = 0;
    uint32_t s = 0;
    for (;;)
    {
        uint8_t b = 0;
        if (!br_u8(r, &b))
            return false;
        v |= (uint64_t)(b & 0x7Fu) << s;
        if ((b & 0x80u) == 0)
            break;
        s += 7;
        if (s > 63)
            return false;
    }
    *out = v;
    return true;
}

static bool br_varu32(br_t *r, uint32_t *out)
{
    uint64_t v = 0;
    if (!br_varu64(r, &v))
        return false;
    if (v > 0xFFFFFFFFu)
        return false;
    *out = (uint32_t)v;
    return true;
}

static int64_t br_zzd64(uint64_t v)
{
    return (int64_t)((v >> 1) ^ (uint64_t)-(int64_t)(v & 1u));
}

static bool br_vari64(br_t *r, int64_t *out)
{
    uint64_t v = 0;
    if (!br_varu64(r, &v))
        return false;
    *out = br_zzd64(v);
    return true;
}

static char *br_str(br_t *r)
{
    uint32_t n = 0;
    if (!br_varu32(r, &n))
        return NULL;
    if (!br_need(r, n))
        return NULL;
    char *s = (char *)IKV_MALLOC((size_t)n + 1);
    if (!s)
        return NULL;
    if (n)
        memcpy(s, r->p, n);
    s[n] = 0;
    r->p += n;
    return s;
}

static ikv_node_t *br_node(br_t *r);

static ikv_node_t *br_fixed_value(br_t *r, ikv_type_t t)
{
    ikv_node_t *n = (ikv_node_t *)IKV_CALLOC(1, sizeof(*n));
    if (!n)
        return NULL;
    n->type = t;

    if (t == IKV_STRING)
    {
        n->value.string = br_str(r);
        if (!n->value.string)
        {
            ikv_free(n);
            return NULL;
        }
        return n;
    }
    if (t == IKV_INT)
    {
        int64_t v = 0;
        if (!br_vari64(r, &v))
        {
            ikv_free(n);
            return NULL;
        }
        n->value.i = v;
        return n;
    }
    if (t == IKV_BOOL)
    {
        uint8_t b = 0;
        if (!br_u8(r, &b))
        {
            ikv_free(n);
            return NULL;
        }
        n->value.b = (b != 0);
        return n;
    }
    if (t == IKV_FLOAT)
    {
        uint64_t u = 0;
        if (!br_u64le(r, &u))
        {
            ikv_free(n);
            return NULL;
        }
        union
        {
            uint64_t u;
            double d;
        } x;
        x.u = u;
        n->value.f = x.d;
        return n;
    }

    ikv_free(n);
    return br_node(r);
}

static ikv_node_t *br_node(br_t *r)
{
    uint8_t ty = 0;
    if (!br_u8(r, &ty))
        return NULL;

    ikv_node_t *n = (ikv_node_t *)IKV_CALLOC(1, sizeof(*n));
    if (!n)
        return NULL;
    n->type = (ikv_type_t)ty;

    if (n->type == IKV_NULL)
        return n;

    if (n->type == IKV_BOOL)
    {
        uint8_t b = 0;
        if (!br_u8(r, &b))
        {
            ikv_free(n);
            return NULL;
        }
        n->value.b = (b != 0);
        return n;
    }

    if (n->type == IKV_INT)
    {
        int64_t v = 0;
        if (!br_vari64(r, &v))
        {
            ikv_free(n);
            return NULL;
        }
        n->value.i = v;
        return n;
    }

    if (n->type == IKV_FLOAT)
    {
        uint64_t u = 0;
        if (!br_u64le(r, &u))
        {
            ikv_free(n);
            return NULL;
        }
        union
        {
            uint64_t u;
            double d;
        } x;
        x.u = u;
        n->value.f = x.d;
        return n;
    }

    if (n->type == IKV_STRING)
    {
        n->value.string = br_str(r);
        if (!n->value.string)
        {
            ikv_free(n);
            return NULL;
        }
        return n;
    }

    if (n->type == IKV_OBJECT)
    {
        object_init(&n->value.object, 64);
        if (!n->value.object.buckets)
        {
            ikv_free(n);
            return NULL;
        }

        uint32_t cnt = 0;
        if (!br_varu32(r, &cnt))
        {
            ikv_free(n);
            return NULL;
        }

        for (uint32_t i = 0; i < cnt; i++)
        {
            char *k = br_str(r);
            if (!k)
            {
                ikv_free(n);
                return NULL;
            }

            ikv_node_t *v = br_node(r);
            if (!v)
            {
                IKV_FREE(k);
                ikv_free(n);
                return NULL;
            }

            IKV_FREE(v->key);
            v->key = k;
            object_set_node(&n->value.object, v);
        }

        return n;
    }

    if (n->type == IKV_ARRAY)
    {
        uint8_t et = 0;
        if (!br_u8(r, &et))
        {
            ikv_free(n);
            return NULL;
        }
        n->value.array.element_type = (ikv_type_t)et;

        uint32_t cnt = 0;
        if (!br_varu32(r, &cnt))
        {
            ikv_free(n);
            return NULL;
        }

        n->value.array.count = 0;
        n->value.array.items = NULL;

        if (cnt)
        {
            n->value.array.items = (ikv_node_t **)IKV_MALLOC(sizeof(ikv_node_t *) * (size_t)cnt);
            if (!n->value.array.items)
            {
                ikv_free(n);
                return NULL;
            }
        }

        if (n->value.array.element_type == IKV_NULL)
        {
            for (uint32_t i = 0; i < cnt; i++)
            {
                ikv_node_t *it = br_node(r);
                if (!it)
                {
                    ikv_free(n);
                    return NULL;
                }
                n->value.array.items[n->value.array.count++] = it;
            }
        }
        else
        {
            ikv_type_t t = n->value.array.element_type;
            for (uint32_t i = 0; i < cnt; i++)
            {
                ikv_node_t *it = br_fixed_value(r, t);
                if (!it)
                {
                    ikv_free(n);
                    return NULL;
                }
                n->value.array.items[n->value.array.count++] = it;
            }
        }

        return n;
    }

    ikv_free(n);
    return NULL;
}

ikv_node_t *ikv__parse_binary_memory_version(const void *data, size_t size, uint32_t version)
{
    if (!data || size < 4 + 1 + 4)
        return NULL;

    const uint8_t *p = (const uint8_t *)data;

    if (p[0] != (uint8_t)'i' || p[1] != (uint8_t)'K' || p[2] != (uint8_t)'v')
        return NULL;

    uint8_t file_ver_digit = p[3];
    uint8_t want_digit = (uint8_t)('0' + (uint8_t)version);
    if (file_ver_digit != want_digit)
        return NULL;

    p += 4;

    if (*p++ != (uint8_t)'b')
        return NULL;

    br_t r;
    r.p = p;
    r.e = (const uint8_t *)data + size;

    uint32_t ver = 0;
    if (!br_u32le(&r, &ver))
        return NULL;

    if (ver != version)
        return NULL;

    char *root_name = br_str(&r);
    if (!root_name)
        return NULL;

    ikv_node_t *root = br_node(&r);
    if (!root)
    {
        IKV_FREE(root_name);
        return NULL;
    }

    IKV_FREE(root->key);
    root->key = root_name;
    return root;
}

ikv_node_t *ikv__parse_binary_node_memory(const void *data, size_t size, size_t *out_consumed)
{
    br_t r;
    ikv_node_t *node = NULL;

    if (!data || size == 0u)
        return NULL;

    r.p = (const uint8_t *)data;
    r.e = r.p + size;

    node = br_node(&r);
    if (!node)
        return NULL;

    if (out_consumed)
        *out_consumed = (size_t)(r.p - (const uint8_t *)data);

    return node;
}

ikv_node_t *ikv__parse_binary_file_version(const char *path, uint32_t version)
{
    if (!path)
        return NULL;

    uint8_t *buf = NULL;
    size_t size = 0u;
    ikv_node_t *root = NULL;

    if (!ikv__read_file_bytes(path, &buf, &size) || !buf)
        return NULL;

    root = ikv__parse_binary_memory_version(buf, size, version);
    IKV_FREE(buf);
    return root;
}

void ikv__object_attach_loaded_node(ikv_node_t *object_node, ikv_node_t *child_node)
{
    if (!object_node || object_node->type != IKV_OBJECT)
        return;
    object_attach_loaded_node(&object_node->value.object, child_node);
}

bool ikv__object_reserve_for_count(ikv_node_t *object_node, uint32_t entry_count)
{
    uint32_t bucket_count = 64u;

    if (!object_node || object_node->type != IKV_OBJECT)
        return false;

    while (bucket_count < (entry_count * 4u) / 3u + 1u)
    {
        if (bucket_count > 0x7FFFFFFFu)
            break;
        bucket_count *= 2u;
    }

    IKV_FREE(object_node->value.object.buckets);
    object_node->value.object.bucket_count = bucket_count;
    object_node->value.object.size = 0u;
    object_node->value.object.buckets = (ikv_node_t **)IKV_CALLOC(bucket_count, sizeof(ikv_node_t *));
    return object_node->value.object.buckets != NULL;
}

ikv_version_t ikv_detect_text_version(const char *src)
{
    if (!src)
        return IKV_VERSION_UNKNOWN;

    while (*src && isspace((unsigned char)*src))
        src++;

    if (strncmp(src, "ikv1", 4) == 0)
        return IKV_VERSION_1;
    if (strncmp(src, "ikv2", 4) == 0)
        return IKV_VERSION_2;
    return IKV_VERSION_UNKNOWN;
}

ikv_version_t ikv_detect_binary_version(const void *data, size_t size)
{
    const uint8_t *p = (const uint8_t *)data;

    if (!p || size < 9)
        return IKV_VERSION_UNKNOWN;
    if (p[0] != (uint8_t)'i' || p[1] != (uint8_t)'K' || p[2] != (uint8_t)'v')
        return IKV_VERSION_UNKNOWN;
    if (p[4] != (uint8_t)'b')
        return IKV_VERSION_UNKNOWN;
    if (p[3] == (uint8_t)'1')
        return IKV_VERSION_1;
    if (p[3] == (uint8_t)'2')
        return IKV_VERSION_2;
    return IKV_VERSION_UNKNOWN;
}

ikv_version_t ikv_detect_file_version(const char *path, bool binary)
{
    uint8_t prefix[16] = {0};
    size_t size = 0u;
    ikv_version_t version = IKV_VERSION_UNKNOWN;

    if (!read_file_prefix(path, prefix, sizeof(prefix), &size))
        return IKV_VERSION_UNKNOWN;

    version = binary ? ikv_detect_binary_version(prefix, size)
                     : ikv_detect_text_version((const char *)prefix);
    return version;
}

bool ikv_write_file(const char *path, const ikv_node_t *root)
{
    return ikv_write_file_version(path, root, (ikv_version_t)IKV_CURRENT_VERSION);
}

bool ikv_write_file_version(const char *path, const ikv_node_t *root, ikv_version_t version)
{
    const ikv_loader_t *loader = ikv_find_loader(version);

    if (!loader || !loader->write_text_file)
        return false;

    return loader->write_text_file(path, root);
}

ikv_node_t *ikv_parse_string(const char *src)
{
    ikv_version_t version = ikv_detect_text_version(src);

    if (version == IKV_VERSION_UNKNOWN)
        version = IKV_VERSION_1;

    return ikv_parse_string_version(src, version);
}

ikv_node_t *ikv_parse_string_version(const char *src, ikv_version_t version)
{
    const ikv_loader_t *loader = ikv_find_loader(version);

    if (!loader || !loader->parse_text_string)
        return NULL;

    return loader->parse_text_string(src);
}

ikv_node_t *ikv_parse_file(const char *path)
{
    uint8_t prefix[16] = {0};
    size_t prefix_size = 0u;
    ikv_version_t version = IKV_VERSION_UNKNOWN;

    if (!read_file_prefix(path, prefix, sizeof(prefix), &prefix_size))
        return NULL;

    version = ikv_detect_binary_version(prefix, prefix_size);
    if (version != IKV_VERSION_UNKNOWN)
        return ikvb_parse_file_version(path, version);

    version = ikv_detect_text_version((const char *)prefix);
    if (version == IKV_VERSION_UNKNOWN)
        version = IKV_VERSION_1;
    return ikv_parse_file_version(path, version);
}

ikv_node_t *ikv_parse_file_version(const char *path, ikv_version_t version)
{
    const ikv_loader_t *loader = ikv_find_loader(version);

    if (!loader || !loader->parse_text_file)
        return NULL;

    return loader->parse_text_file(path);
}

bool ikvb_write_memory(const ikv_node_t *root, uint8_t **out_data, uint32_t *out_size)
{
    return ikvb_write_memory_version(root, out_data, out_size, (ikv_version_t)IKV_CURRENT_VERSION);
}

bool ikvb_write_memory_version(const ikv_node_t *root, uint8_t **out_data, uint32_t *out_size, ikv_version_t version)
{
    const ikv_loader_t *loader = ikv_find_loader(version);

    if (!loader || !loader->write_binary_memory)
        return false;

    return loader->write_binary_memory(root, out_data, out_size);
}

bool ikvb_write_file(const char *path, const ikv_node_t *root)
{
    return ikvb_write_file_version(path, root, (ikv_version_t)IKV_CURRENT_VERSION);
}

bool ikvb_write_file_version(const char *path, const ikv_node_t *root, ikv_version_t version)
{
    const ikv_loader_t *loader = ikv_find_loader(version);

    if (!loader || !loader->write_binary_file)
        return false;

    return loader->write_binary_file(path, root);
}

ikv_node_t *ikvb_parse_memory(const void *data, size_t size)
{
    ikv_version_t version = ikv_detect_binary_version(data, size);

    return ikvb_parse_memory_version(data, size, version);
}

ikv_node_t *ikvb_parse_memory_version(const void *data, size_t size, ikv_version_t version)
{
    const ikv_loader_t *loader = ikv_find_loader(version);

    if (!loader || !loader->parse_binary_memory)
        return NULL;

    return loader->parse_binary_memory(data, size);
}

ikv_node_t *ikvb_parse_file(const char *path)
{
    ikv_version_t version = ikv_detect_file_version(path, true);
    if (version == IKV_VERSION_UNKNOWN)
        return NULL;
    return ikvb_parse_file_version(path, version);
}

ikv_node_t *ikvb_parse_file_version(const char *path, ikv_version_t version)
{
    const ikv_loader_t *loader = ikv_find_loader(version);

    if (!loader || !loader->parse_binary_file)
        return NULL;

    return loader->parse_binary_file(path);
}