#pragma once
#include "base_core.h"


typedef U32 ArenaFlags; // no flags defined yets

typedef struct ArenaParams ArenaParams;
struct ArenaParams {
    U32 size;
    U32 commit_size;
    ArenaFlags flags; // No flags defined yet
};

typedef struct MemoryBlock MemoryBlock;
struct MemoryBlock {
    U8 *base;
    U32 size;
    U32 pos;          // start of next allocation
    U32 base_pos;     // absolute position of base relative to the first linked arena
    U32 committed_pos;
    MemoryBlock *prev;
};

typedef struct Arena Arena;
struct Arena {
    MemoryBlock *current;
    U32 block_size;
    U32 commit_size;
    ArenaFlags flags;
    S32 checkpoint_level;
};

typedef struct ArenaCheckPoint ArenaCheckPoint;
struct ArenaCheckPoint {
    Arena *arena;
    U32 absolute_pos;
};

StaticAssert(sizeof(MemoryBlock) <= 64);
#define MemoryBlock_Header_Size 64u



void arena_init(Arena *arena, const ArenaParams *params);

void arena_free(Arena *arena);
void *arena_push(Arena *arena, U32 size, U32 align);

#define arena_push_type(arena, type) arena_push(arena, (U32)sizeof(type), alignof(type))
#define arena_push_array_of(arena, type, len) arena_push(arena, (U32) (sizeof(type) * (len)), alignof(type))

ArenaCheckPoint arena_temp_begin(Arena *arena);
void arena_temp_end(ArenaCheckPoint *checkpoint);
void arena_pop_to(Arena *arena, U32 abs_pos);
void arena_reset(Arena *arena);
MemoryBlock *memoryblock_allocate(size_t size, size_t commit_size);


static INLINE U32 memoryblock_available(const MemoryBlock *block)
{
    return block->size - block->pos;
}

static INLINE U32 arena_used(const Arena *arena)
{
    const MemoryBlock *block = arena->current;
    return block->base_pos + block->pos;
}