#ifndef SOCKS_VM_H_
#define SOCKS_VM_H_

#include <stddef.h>
#include <socks/types.h>
#include <socks/status.h>
#include <socks/queue.h>

#define VM_CHECK_ALIGN(p, mask) ((((p) & (mask)) == (p)) ? 1 : 0)
#define VM_PAGE_SIZE  0x1000
#define VM_PAGE_SHIFT 12

typedef phys_addr_t vm_alignment_t;

typedef struct vm_object {
	unsigned int reserved;
} vm_object_t;

typedef enum vm_zone_id {
	VM_ZONE_DMA     = 0u,
	VM_ZONE_NORMAL  = 1u,
	VM_ZONE_HIGHMEM = 2u,
	VM_ZONE_MIN     = VM_ZONE_DMA,
	VM_ZONE_MAX     = VM_ZONE_HIGHMEM,
} vm_zone_id_t;

typedef enum vm_page_order {
	VM_PAGE_4K = 0u,
	VM_PAGE_8K,
	VM_PAGE_16K,
	VM_PAGE_32K,
	VM_PAGE_64K,
	VM_PAGE_128K,
	VM_PAGE_256K,
	VM_PAGE_512K,
	VM_PAGE_1M,
	VM_PAGE_2M,
	VM_PAGE_4M,
	VM_PAGE_8M,
	VM_PAGE_16M,
	VM_PAGE_32M,
	VM_PAGE_64M,
	VM_PAGE_128M,
	VM_PAGE_256M,
	VM_PAGE_512M,
	VM_PAGE_1G,
	VM_PAGE_MIN_ORDER = VM_PAGE_4K,
	VM_PAGE_MAX_ORDER = VM_PAGE_1G,
} vm_page_order_t;

typedef enum vm_memory_region_status {
	VM_REGION_FREE		= 0x01u,
	VM_REGION_RESERVED	= 0x02u,
} vm_memory_region_status_t;

typedef struct vm_zone_descriptor {
	vm_zone_id_t zd_id;
	unsigned int zd_node;
	const char zd_name[32];
	phys_addr_t zd_base;
	phys_addr_t zd_limit;
} vm_zone_descriptor_t;

typedef struct vm_zone {
	vm_zone_descriptor_t z_info;

	queue_t z_free_pages[VM_PAGE_MAX_ORDER + 1];
	unsigned long z_size;
} vm_zone_t;

typedef struct vm_pg_data {
	vm_zone_t pg_zones[VM_ZONE_MAX + 1];
} vm_pg_data_t;

typedef struct vm_region {
	vm_memory_region_status_t r_status;
	phys_addr_t r_base;
	phys_addr_t r_limit;
} vm_region_t;

typedef enum vm_page_flags {
	/* page is reserved (probably by a call to memblock_reserve()) and cannot be
	   returned by any allocation function */
	VM_PAGE_RESERVED   = 0x01u,
	/* page is the first page of a huge-page */
	VM_PAGE_HEAD       = 0x02u,
	/* page is part of a huge-page */
	VM_PAGE_HUGE       = 0x04u,
} vm_page_flags_t;

typedef struct vm_page {
	/* vm_page_flags_t bitfields.
	   the 2 most significant bits of this field encode the ID of the vm_zone that
	   the page belongs to */
	uint32_t p_flags;

	/* buddy allocator free page list head (vm_zone_t->z_free_pages[p_order]) */
	queue_entry_t p_free_list;

	/* temporary */
	vm_zone_t *p_zone;

	/* order of the page block that this page belongs too */
	unsigned char p_order;
} __attribute__((aligned(2 * sizeof(unsigned long)))) vm_page_t;

extern kern_status_t vm_bootstrap(const vm_zone_descriptor_t *zones, size_t nr_zones);

extern vm_pg_data_t *vm_pg_data_get(int node);

extern void vm_page_init_array();
extern vm_page_t *vm_page_get(phys_addr_t addr);
extern phys_addr_t vm_page_get_paddr(vm_page_t *pg);
extern vm_zone_t *vm_page_get_zone(vm_page_t *pg);
extern void *vm_page_get_vaddr(vm_page_t *pg);
extern size_t vm_page_get_pfn(vm_page_t *pg);
extern size_t vm_page_order_to_bytes(vm_page_order_t order);
extern size_t vm_page_order_to_pages(vm_page_order_t order);
extern vm_alignment_t vm_page_order_to_alignment(vm_page_order_t order);

extern size_t vm_bytes_to_pages(size_t bytes);

extern void vm_zone_init(vm_zone_t *z, const vm_zone_descriptor_t *zone_info);

#endif