#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)
{
    u8 padding = 0;

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

    if(alignment > 128)
        {
            alignment = 128;
        }

    u64 current_address = (u64)stack->base_position + stack->current_offset;
    padding             = calculate_padding(current_address, alignment, sizeof(MemStackHeader));

    if(stack->current_offset + padding + size > stack->capacity)
        {
            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 *)MemSet((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);
    memmove(new_pointer, pointer, min_size);
    return (MemStack *)new_pointer;
}

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