#ifndef MEM_H_
#define MEM_H_ 1

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

#include "multiboot.h"

typedef uintptr_t paddr_t;
typedef uintptr_t vaddr_t;

extern uintptr_t _kernel_end;
extern uintptr_t _kernel_vma;
extern uintptr_t _kernel_phys_end;
extern uintptr_t _kernel_size;
extern uintptr_t _asm_physmap;

extern void *bios_ebda;

/* These are in memx64.s */
extern void flush_tlb(void *va);
extern void switch_address_space(uintptr_t cr3);

void vmem_test();

/* map one physical page to a virtual address */
#define PHY2VIRTP(pa) ( (void *)(((paddr_t)pa) + memory.physmap) )
/* only works for the linear mapped physical memory */
#define VIRTP2PHY(va) ( (paddr_t)(((vaddr_t)(va)) - memory.physmap) )
#define KB(x) ((x) * (1<<10))
#define MB(x) ((x) * (1<<20))
#define GB(x) (((uint64_t)x) * (1ULL<<30))
#define TB(x) (((uint64_t)x) * (1ULL<<40))
uintptr_t mem_align(uintptr_t a, size_t alignment);

/*
 * kernel is at 0xFFFFFFFF80000000 and up
 * we will map in all physical memory below that
 */

/* structure of physical frames */
struct frame {
	struct frame *next;
	void *paddr; /* the physical address of the frame */
	struct frame *prev;
	void *top, *base;
	uint64_t magic;
};

/* a map of memory */
/* TODO fix these types.  maybe add a physvend */
struct memory {
	void *kbase; /* at 0xFFFFFFFF00000000 */
	void *kstack; /* grow down from -1 ? */
	uintptr_t kend; /* virtual address of top of kernel */
	uintptr_t kphysend; /* physical address of top of kernel */
	uintptr_t phys_max; /* maximum (usable) physical address + 1 */
	uintptr_t physmap; /* all physical memory is mapped starting here */
	/* kbase + kernel size ?, then put dynamic kernel structures above that,
	 * growing toward the stack?
	 */ 
};

/* TODO keep track of the kernel virtual address of page, we could
 * re-alloc it in the same spot
 */
struct pstack {
	paddr_t page_addr[510]; /* physical addresses of frames */
	size_t pages; /* free pages in this stack frame */
	struct pstack *next; /* address of next stack frame */
};

/*
 * free a page:
 * if there is no room in the stack, then
 * set the phys.stack.next to the new page
 * map the new page in at phys.stack
 * then add to phys.stack.pages
 * the physical address to the stack.pages
 *
 * get a page:
 * if there are no pages free on the stack:
 * map in the  phys.stack.next to phys.stack
 * hand out the old page, which is on pages[free]
 * 
 * it's probably worth memoizing the virtual address
 * of the exact place where the stack vm map page is stored
 * in the page tables
 */
extern struct memory memory;

/* physical memory manager */
struct phys {
	struct frame *base;
	struct frame *top;
	size_t frame_size;
	int64_t offset; /* paddr = vaddr + offset */
	struct phys *next;

	vaddr_t kmap; /* physical address of page table entry for *stack */
	vaddr_t *page_map; /* temporary page map space */
	struct pstack *stack; /* virtual address of top of page stack */
	size_t free;    /* total number of free pages */

};
/*
 * pa = va + pb - vb
 * va = pa + vb - pb
 */

extern struct memory memory;
extern struct phys phys;

/*
 * ops:
 * add - add a contiguous chunk of physical memory and a virtual address base.
 * alloc - get a page of memory
 * free  - free a page of memory
 * tinyalloc - get a really small page, 256 bytes
 * tinyfree  - 
 */

/* TODO lazy setup of the memory block stack */
/* TODO modify phys_init to be "more core" to support
 * discontiguous memory addresses
 */

/* These don't have to be the same as the hardware paging, but
 * it probably helps
 */
/* Hmm, need to map in memory for this to work */
/*
 * pa = va + pb - vb
 * va = pa + vb - pb
 */

uint64_t getcr3(); /* probably in assembly */

paddr_t create_addrspace(void);


void test_address(void *);
void phys_init(struct multiboot_info *mbi);
void mem_init();
paddr_t palloc();
void pfree(paddr_t vmem);
void *koalloc(size_t size);
void kofree(void *, size_t size);
void dumpostacks(int f, int t);

uint64_t makecr3(void *pml4) ;
void *virt2phys(void *vaddr) ;

extern uint64_t kernel_space; /* physical address of kernel space? */
#define MEM_KERNEL (kernel_space)
#define KERNEL_PML4 ((struct pml4t *)PHY2VIRTP(kernel_space))

extern paddr_t pci_start;

struct cr3 {
	uint64_t reslow:3; /* should be cleared to zero */
	uint64_t pwt:1;		/* page writethrough */
	uint64_t pcd:1;		/* page cache disable */
	uint64_t resmed:7;	/* clear to zero */
	uint64_t addr:40;	/* pml4 page base physical address shifted right 12 */
	uint64_t reshigh:12;	/* clear to zero */
};

/* TODO last bit (63) is actually a no-execute bit */
struct pml4e {
	uint64_t present:1;
	uint64_t rw:1;
	uint64_t user:1;
	uint64_t pwt:1;
	uint64_t pcd:1;
	uint64_t a:1;
	uint64_t ign:1;
	uint64_t mbz:2;
	uint64_t avl:3;
	uint64_t addr:40;	/* pml4 page base physical address shifted right 12 */
	uint64_t reshigh:12;	/* clear to zero */
};

struct pdpe {
	uint64_t present:1;
	uint64_t rw:1;
	uint64_t user:1;
	uint64_t pwt:1;
	uint64_t pcd:1;
	uint64_t a:1;
	uint64_t ign:1;
	uint64_t ps:1; /* I think this is the PS bit: 0 for 4KB or 2MB, 1 for 1GB */
	uint64_t mbz:1;
	uint64_t avl:3;
	uint64_t addr:40;	/* pml4 page base physical address shifted right 12 */
	uint64_t reshigh:12;	/* clear to zero */
};

struct pde {
	uint64_t present:1;
	uint64_t rw:1;
	uint64_t user:1;
	uint64_t pwt:1;
	uint64_t pcd:1;
	uint64_t a:1;
	uint64_t ign:1;
	uint64_t ps:1; /* I think this is the PS bit: 0 for 4KB */
	uint64_t mbz:1;
	uint64_t avl:3;
	uint64_t addr:40;	/* pml4 page base physical address shifted right 12 */
	uint64_t reshigh:12;	/* clear to zero */
};

struct pte {
	uint64_t present:1;
	uint64_t rw:1;
	uint64_t user:1;
	uint64_t pwt:1;
	uint64_t pcd:1;
	uint64_t a:1;
	uint64_t d:1;
	uint64_t pat:1;
	uint64_t g:1;
	uint64_t avl:3;
	uint64_t addr:40;	/* pml4 page base physical address shifted right 12 */
	uint64_t reshigh:12;	/* clear to zero */
};

struct pml4t {
	struct pml4e pml4e[512];
};

struct pdpt {
	struct pdpe pdpe[512];
};

struct pdt {
	struct pde pde[512];
};

struct pt {
	struct pte pte[512];
};

struct vaddr_decode {
	/* broken down virtual address */
	int pml4offset, pdpoffset, pdoffset, ptoffset;
	paddr_t offset; /* physical page offset */

	struct pml4t *pml4t; /* pml4 base address */
	paddr_t pml4_phys; /* pml4 physical base address */

	struct pml4e pml4e; /* entry in page map level 4 */
	/* at pml4 + 8 * pml4offset */

	struct pdpe  pdpe; /* entry in page directory pointer table */
	/* at virt(pml4e.addr) + 8 * pdpoffset */
	/* does not exist unless pml4e.present */
	/* pdpe.ps == 1 means 1 GB pages, and the next level doesn't exist */
	/* offset = vaddr & 0x3fffffff, physical page = standard - offset */
	
	struct pde   pde; /* entry in page directory table */
	/* at virt(pdpe.addr) + 8 * pdoffset */
	/* does not exist unless pdpe.present */
	/* pde.ps == 0 means 4 KB pages and the next level exists if present */
	/* pds.ps == 1 means 2 MB pages, pts doesn't exist and
	 * offset = vaddr & 0x1fffff; i.e. low 21 bits
	 * physical page address = same mask minus offset bits
	 */
	
	struct pte   pte; /* entry in page table */
	/* at virt(pde.addr) + 8 * ptoffset */
	/* does not exist unless pde.present */
	/* offset = vaddr & 0xfff; i.e. low 12 bits */
	/* physical page address = pde.addr, or vaddr & 0xffffffffff000 */

	struct pte	*pteptr; /* a pointer to the actual entry */

	/* actual physical addresses */
	paddr_t pdpt_phys;
	paddr_t pdt_phys;
	paddr_t pt_phys;

	int present; /* physical address actually mapped */
	paddr_t paddr; /* decoded physical address */
	int level;
	paddr_t page; /* physical address of page */
	size_t pagesize;
};

void decode_vaddr(struct vaddr_decode *ds, uint64_t space, vaddr_t vaddr);
void print_decode(struct vaddr_decode *ds, uint64_t space, vaddr_t vaddr);

/* returns addr.  addr may be null in which case the function will allocate virtual space */
void *map_page(uint64_t space, vaddr_t addr, paddr_t pa, unsigned int flags);
void vmapz(uint64_t space, vaddr_t addr, size_t length, unsigned int flags);

#define PT_PRESENT 0x1
#define MEM_PCD (1<<4)
#define MEM_PWT (1<<3)
#define MEM_USER (1<<2)
#define MEM_RW (1<<1)
#define MAP_TRACE (1<<16)

#define MEM_NOCACHE (MEM_PCD | MEM_PWT)
#define MEM_MMIO (PT_PRESENT|MEM_NOCACHE|MEM_RW)
#define MEM_USERSPACE (MEM_USER | MEM_RW)

#if 0
typedef struct page {
   u32int present    : 1;   // Page present in memory
   u32int rw         : 1;   // Read-only if clear, readwrite if set
   u32int user       : 1;   // Supervisor level only if clear
   u32int accessed   : 1;   // Has the page been accessed since last refresh?
   u32int dirty      : 1;   // Has the page been written to since last refresh?
   u32int unused     : 7;   // Amalgamation of unused and reserved bits
   u32int frame      : 20;  // Frame address (shifted right 12 bits)
} page_t;

#endif

struct bios_data_area {
	uint16_t	comaddr[4];
	uint16_t	lpt[3];
	uint16_t	ebda; /* <<4 to get actual */
};

#endif