// TODO: the previous position of the stack header never get's set
// TODO: renmae current_position in arena.cpp and arena.h to current_address or vice versa

#if PLATFORM_LINUX
internal MemStack *unix_stack_create(u64 capacity)
{
    MemStack *stack = (MemStack *)mmap(0, capacity + sizeof(MemStack), PROT_READ | PROT_WRITE,
                                       MAP_SHARED | MAP_ANONYMOUS, -1, 0);

    if (stack == MAP_FAILED) {
        return NULL;
    }

    stack->capacity       = capacity;
    stack->base_position  = (u8 *)stack + sizeof(MemStack);
    stack->current_offset = 0;

    return stack;
}

internal void unix_stack_destroy(MemStack *stack)
{
    if (!stack) {
        return;
    }

    munmap(stack, stack->capacity + sizeof(MemStack));
}
#endif // PLATFORM_LINUX

#if PLATFORM_WINDOWS

// request a page from the operating system
internal MemStack *win32_stack_create(u64 capacity)
{
    MemStack *stack = (MemStack *)VirtualAlloc(NULL, capacity + sizeof(MemStack),
                                               MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);

    if (!stack) {
        Log("Failed to receive a memory address from the operating system");
        return NULL;
    }

    stack->capacity       = capacity;
    stack->base_position  = (u8 *)stack + sizeof(MemStack);
    stack->current_offset = 0;
    return stack;
}

internal void win32_stack_destroy(MemStack *stack)
{
    b32 result = VirtualFree(stack,
                             0, // stands for the byte of committed pages
                             MEM_RELEASE);

    if (!result) {
        Log("Failed to receive a memory address from the operating system");
    }
}

#endif // PLATFORM_WINDOWS

internal u8 calculate_padding(u64 pointer, u8 alignment, u64 header_size)
{
    u8 modulo, padding;

    if (!is_pow(alignment)) {
        return 0;
    }

    modulo = pointer & (u8)(alignment - 1);

    padding = 0;

    if (0 != modulo) {
        padding = alignment - modulo;
    }

    if (padding < header_size) {
        header_size -= padding;

        if ((header_size & (alignment - 1)) != 0) {
            padding += alignment * (1 + (u8)(header_size / alignment));
        } else {
            padding += alignment * ((u8)(header_size / alignment));
        }
    }

    return padding;
}

internal MemStack *stack_push_align(MemStack *stack, u64 size, u8 alignment)
{
    // NOTE: satifisying static analyzer
    AssertLog((stack != NULL), "STACK IS NULL");
    u8 padding = 0;

    // NOTE: this shouln't be possible because we have the allignment predefined
    // so it's bassically a useless check

    if (!is_pow(alignment)) {
        breakpoint();
        return (0);
    }

    if (alignment > 128) { // NOTE: where does the 128 come from?
        alignment = 128;
    }

    u64 current_address;
    current_address = (u64)stack->base_position + stack->current_offset; // NOTE: we already we're checking if the stack existed
    padding = calculate_padding(current_address, alignment, sizeof(MemStackHeader));

    if (stack->current_offset + padding + size > stack->capacity) {
        breakpoint();
        return 0;
    }

    stack->current_offset += padding;

    u64 next_address       = current_address + (u64)padding;
    MemStackHeader *header = (MemStackHeader *)(next_address - sizeof(MemStackHeader));
    header->padding        = padding;

    stack->current_offset += size;

    return (MemStack *)MemSetZero((MemStack *)next_address, size);
}

internal void *stack_push(MemStack *stack, u64 size)
{
    return stack_push_align(stack, size, arena_align);
}

internal void stack_pop(MemStack *stack, void *pointer)
{
    if (pointer != NULL) {
        u64 start, end, current_address;
        MemStackHeader *header;
        u64 prev_offset;

        start           = (u64)stack->base_position;
        end             = start + (u64)stack->capacity;
        current_address = (u64)pointer;

        if (!(start <= current_address && current_address < end)) {
            if (0 && "Out of bounds memory address passed to stack allocator (free)") {
                return;
            }
            return;
        }

        if (current_address >= start + (u64)stack->current_offset) {
            return;
        }

        header                = (MemStackHeader *)(current_address - sizeof(MemStackHeader));
        prev_offset           = (size_t)(current_address - (u64)header->padding - start);
        stack->current_offset = prev_offset;
    }
}

internal MemStack *stack_resize_align(MemStack *stack, void *pointer, u64 old_size, u64 new_size,
                                      u8 alignment)
{
    if (pointer == NULL) {
        return stack_push_align(stack, new_size, alignment);
    } else if (new_size == 0) {
        stack_pop(stack, pointer);
        return NULL;
    }

    u64 start, end, current_address;
    u64 min_size = old_size < new_size ? old_size : new_size;
    void *new_pointer;

    start           = (u64)stack->base_position;
    end             = start + (u64)stack->capacity;
    current_address = (u64)pointer;
    if (!(start <= current_address && current_address < end)) {
        return NULL;
    }

    if (current_address >= start + (u64)stack->current_offset) {
        return NULL;
    }

    if (old_size == new_size) {
        return (MemStack *)pointer;
    }

    new_pointer = stack_push_align(stack, new_size, alignment);
    AssertLog((new_pointer != NULL), "stack_push_align failed in stack_resize_align");
    memmove(new_pointer, pointer, min_size);
    return (MemStack *)new_pointer;
}

internal MemStack *arena_to_stack(MemArena *arena, u64 requested_size)
{

    Assert(arena);

    MemStack *stack = PushStruct(arena, MemStack);
    u8 *buffer = PushArray(arena, u8, requested_size);

    stack->header         = 0;
    stack->base_position  = buffer;
    stack->capacity       = requested_size;
    stack->current_offset = 0;

    return stack;
}

#if 0
#if MEM_DEBUG
global_variable String8List *stack_log; // TODO: initialize this in the mem stack callback

#endif

internal void
stack_debug_view(MemArena *global_arena, MemStack *stack)
{

    if(!stack_log)
    {
        stack_log = PushStruct(global_arena, String8List);
    }


}
#endif

internal void stack_clear(MemStack *stack) { stack->current_offset = 0; }