#include <stdint.h>

#ifdef JRK_IMPLEMENTATION_WITH_SHORTNAMES
#define JRK_IMPLEMENTATION
#define JRK_SHORTNAMES
#endif // JRK_IMPLEMENTATION_WITH_SHORTNAMES

typedef int8_t i8;
typedef int16_t i16;
typedef int32_t i32;
typedef int64_t i64;

typedef uint8_t u8;
typedef uint16_t u16;
typedef uint32_t u32;
typedef uint64_t u64;

typedef float f32;
typedef double f64;

typedef struct {
    u8 *data;
    u64 length;
    u64 capacity;
} jrk_Arena;

typedef struct {
    char *items;
    u64 count;
    u64 capacity;
} jrk_StringBuilder;

void *jrk_ecalloc(u64, u64);
void *jrk_erealloc(void*, u64);

jrk_Arena jrk_arena_create(u64);
void *jrk__arena_push(jrk_Arena*, u64);
void jrk_arena_expand(jrk_Arena*, u64);

i32 jrk_rand_num(i32);
i32 jrk_rand_num_range(i32, i32);

/* NOTE(jake): no shortname as 'assert' is just too generic */
#define jrk_assert(c, msg) do { if (!(c)) jrk_die("jrk_assert: "msg); } while(0)

#define jrk_emalloc(n) jrk_ecalloc(1, n)

#define jrk_arena_destroy(arena) ((arena.data) ? free(arena.data) : (void) 0)
#define jrk_arena_push_array(arena, type, n) (type *) jrk__arena_push(arena, sizeof(type) * n)
#define jrk_arena_push_struct(arena, type) (type *) jrk__arena_push(arena, sizeof(type))

#define jrk_da_reserve(da, expected_capacity)                                               \
    do {                                                                                    \
        if ((expected_capacity) > (da)->capacity) {                                         \
            if ((da)->capacity == 0) {                                                      \
                (da)->capacity  = 4;                                                        \
            }                                                                               \
            while ((expected_capacity) > (da)->capacity) {                                  \
                (da)->capacity *= 2;                                                        \
            }                                                                               \
            (da)->items = jrk_erealloc((da)->items, (da)->capacity * sizeof(*(da)->items)); \
            jrk_assert((da)->items, "buy more ram lol");                                    \
        }                                                                                   \
    } while (0)

#define jrk_da_append(da, item)                \
    do {                                       \
        jrk_da_reserve((da), (da)->count + 1); \
        (da)->items[(da)->count++] = (item);   \
    } while (0);

#define jrk_da_append_many(da, new_items, new_items_count)                                      \
    do {                                                                                        \
        jrk_da_reserve((da), (da)->count + (new_items_count));                                  \
        memcpy((da)->items + (da)->count, (new_items), (new_items_count)*sizeof(*(da)->items)); \
        (da)->count += (new_items_count);                                                       \
    } while (0)

#define jrk_da_create(name, type) \
    struct name {                 \
        type *items;              \
        u64 count;                \
        u64 capacity;             \
    };                            \
    typedef struct name name

#define jrk_da_free(da)                                               \
    do {                                                              \
    jrk_assert((da).items, "bad free: jrk_da_free da.items is NULL"); \
    free((da).items);                                                 \
    } while (0)


#define jrk_da_foreach(type,it,da) for (type *it = (da)->items; it < (da)->items + (da)->count; ++it)

#define jrk_sb_append_null(sb) jrk_da_append_many(sb, "\0", 1)
#define jrk_sb_free(sb) jrk_da_free(sb)

#define jrk_sb_append_cstr(sb, cstr)  \
    do {                              \
        const char *s = (cstr);       \
        i64 n = strlen(cstr);         \
        jrk_da_append_many(sb, s, n); \
    } while (0)

#define jrk_sb_append_buf(sb, buf, size) jrk_da_append_many(sb, buf, size)

#ifdef JRK_SHORTNAMES
#define Arena jrk_Arena
#define StringBuilder jrk_StringBuilder

#define sb_appendf jrk_sb_appendf
#define sb_append_null jrk_sb_append_null
#define sb_append_buf jrk_sb_append_buf
#define sb_append_cstr jrk_sb_append_cstr
#define sb_free jrk_sb_free

#define ecalloc jrk_ecalloc
#define erealloc jrk_erealloc
#define emalloc jrk_emalloc

#define da_reserve jrk_da_reserve
#define da_append jrk_da_append
#define da_append_many jrk_da_append_many
#define da_foreach jrk_da_foreach
#define da_create jrk_da_create
#define da_free jrk_da_free

#define arena_create jrk_arena_create
#define arena_destroy jrk_arena_destroy
#define arena_push_struct jrk_arena_push_struct
#define arena_push_array jrk_arena_push_array
#define arena_expand jrk_arena_expand

#define rand_num jrk_rand_num
#define rand_num_range jrk_rand_num_range
#endif // JRK_SHORTNAMES

#ifdef JRK_IMPLEMENTATION
#include <errno.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define jrk_die(x) do { fprintf(stderr, "%s:%d: error: "x"\n", __FILE__, __LINE__); exit(69); } while(0)
#define jrk_edie(x) do { fprintf(stderr, "%s:%d: error: "x": %s\n", __FILE__, __LINE__, strerror(errno)); exit(69); } while(0)

#ifdef JRK_SHORTNAMES
#define die jrk_die
#define edie jrk_edie
#endif // JRK_SHORTNAMES

void *
jrk_ecalloc(u64 nmemb, u64 size)
{
    void *p;

    if (!(p = calloc(nmemb, size)))
        jrk_edie("jrk_ecalloc");
    return p;
}

void *
jrk_erealloc(void *ptr, u64 size)
{
    void *p;

    if (!(p = realloc(ptr, size)))
        edie("jrk_erealloc");
    return p;
}

jrk_Arena
jrk_arena_create(u64 n)
{
    jrk_Arena result;
    result.length = 0;
    result.capacity = n;
    result.data = jrk_ecalloc(result.capacity, 1);
    return result;
}

void *
jrk__arena_push(jrk_Arena *arena, u64 n)
{
    while (arena->length + n >= arena->capacity)
        jrk_arena_expand(arena, arena->capacity * 2);

    void *result = &arena->data[arena->length];
    arena->length += n;
    return result;
}

void
jrk_arena_expand(jrk_Arena *arena, u64 new_capacity)
{
    u8 *tmp = jrk_erealloc(arena->data, new_capacity);

    arena->capacity = new_capacity;
    arena->data = tmp;
}

i32
jrk_sb_appendf(jrk_StringBuilder *sb, const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    i32 n = vsnprintf(NULL, 0, fmt, args);
    va_end(args);

    jrk_da_reserve(sb, sb->count + n + 1);
    va_start(args, fmt);
    vsnprintf(sb->items + sb->count, n + 1, fmt, args);
    va_end(args);
    sb->count += n;

    return n;
}

i32
jrk_rand_num(i32 upbound)
{
    return rand() % upbound + 1;
}

i32
jrk_rand_num_range(i32 min, i32 max)
{
    return rand() % (max - min + 1) + min;
}

#endif // JRK_IMPLEMENTATION