#pragma once

#include <stddef.h>
#include <stdint.h>
#include <shim.h>

/**
 * Initalize system memory allocator
 */
extern void memory_init(struct memory_map *map);

/**
 * Disabled cpu interupts to not interfere with
 * current memory allocations.
 */
extern void memory_lock(void);

/**
 * Reenabled cpu interupts
 */
extern void memory_unlock(void);

/**
 * @returns how much memory the system has
 */
extern uint64_t memory_total(void);

/**
 * @returns how much memory is free
 */
extern uint64_t memory_free(void);

/**
 * @returns how much memory is used
 */
extern uint64_t memory_used(void);

/**
 * Allocates a single page in memory.
 * @returns the page if allocated or NULL on failure
 */
extern void *alloc_page(void);

/**
 * Allocats count pages in memory
 * @param count - the number of continious pages to allocate
 * @returns the pages if allocated or NULL on failure
 */
extern void *alloc_pages(int count);

/**
 * Frees a signle page in memory.
 * Must be a page aligned allocated vitural pointer.
 * Freeing in the middle of a block is allowed.
 * @param page - the pointer to the page
 */
extern void free_page(void *page);
// TODO: implement free_page

/**
 * Frees block of pages in memory.
 * Must be a page aligned allocated vitural pointer.
 * Freeing int he middle of a block is allowed,
 * free_pages will from *page to end of block allocated.
 * @param page - the pointer to the page
 */
extern void free_pages(void *page);
// TODO: implement freeing in middle of block

/**
 * Allocates at least len bytes of memory starting at
 * physical address addr. Returned address can be
 * any virtural address.
 * @param addr - the physical address to map
 * @param len - the minimum length to map
 * @param writable - if this memory should be writable
 * @param user - if this memory should be user writable
 */
extern void *mmap(void *addr, size_t len);

/**
 * Unmaps mapped address from the mmap function
 * @param addr - the address returned from mmap
 * @param len - the length allocated
 */
extern void unmap(void *addr);

/**
 * Allocates size_t bytes in memory
 * @param size - the amount of bytes to allocate
 * @retruns the address allocated or NULL on failure
 */
extern void *kalloc(size_t size);

/**
 * Reallocates a given allocated ptr to a new size of bytes in memory.
 * If ptr is NULL it will allocate new memory.
 * @param ptr - the pointer to reallocate
 * @param size - the amount of bytes to set the pointer to
 * @returns the address allocated or NULL on failure
 */
extern void *krealloc(void *ptr, size_t size);

/**
 * Frees a allocated pointer in memory
 * @param ptr - the pointer to free
 */
extern void kfree(void *ptr);