#pragma once

#include <ctype.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <stdio.h>


#define DECLARE_VEC(T, Name)                                        \
    typedef struct {                                                \
        T* items;                                                   \
        size_t count;                                               \
        size_t cap;                                                 \
        size_t incr_step;                                           \
    } Name;                                                         \
    static inline Name make_##Name(size_t step) {                   \
        return (Name) {                                             \
            .items = malloc(step* sizeof(T)),                       \
            .count = 0,                                             \
            .cap = step,                                            \
            .incr_step = step,                                      \
        };                                                          \
    }                                                               \
    static inline void push_to_##Name(Name* vec, T item) {          \
        if (vec->count == vec->cap) {                               \
            vec->cap += vec->incr_step;                             \
            vec->items = realloc(                                   \
                vec->items,                                         \
                vec->cap * sizeof(T)                                \
            );                                                      \
        }                                                           \
        vec->items[vec->count++] = item;                            \
    }                                                               


DECLARE_VEC(char, String);

static void append_str_to_String(String* target, char* src_str) {
    size_t required_size = 
        ((target->count + strlen(src_str)) / target->incr_step + 1) * target->incr_step; 
    if (required_size > target->cap) {
        target->cap = required_size;
        target->items = realloc(target->items, required_size * sizeof(char));
    }
    memcpy(target->items + target->count, src_str, strlen(src_str));
    target->count += strlen(src_str);
}

static inline char* inner(String str) {
    if (str.count == str.cap) {
        str.items = realloc(str.items, (str.cap+1)*sizeof(char));
    }
    str.items[str.count] = '\0';
    return str.items;
}

#define DECLARE_MAYBE(T)                                            \
    typedef struct {                                                \
        bool some;                                                  \
        T value;                                                    \
    } Maybe##T;