#define FOOLOS_MODULE_NAME "mem"

#include <stdint.h>

#include "config.h"
#include "lib/logger/log.h"	// logger facilities

//! 8 blocks per byte
#define PMMNGR_BLOCKS_PER_BYTE 8
 
//! block size (4k)
#define PMMNGR_BLOCK_SIZE	4096
 
//! block alignment ??? TODO: what is this!?
#define PMMNGR_BLOCK_ALIGN	PMMNGR_BLOCK_SIZE


//memory map bit array. Each bit represents a 4KB memory block
static uint32_t *_mmngr_memory_map;
static uint32_t mem_free_blocks;
static uint32_t mem_array_size;

char *memmap_type_to_string[]=
    {
    	"Usable",
	"Reserved",
	"ACPI reclaimable",
	"ACPI NVS",
	"Bad Memory"
    };

// bit funcs!
void mmap_set(int bit) 
{
      _mmngr_memory_map[bit / 32] |= (1 << (bit % 32));
}

void mmap_unset(int bit)
{
      _mmngr_memory_map[bit / 32] &= ~ (1 << (bit % 32));
}

int  mmap_test(int bit)
{
     return _mmngr_memory_map[bit / 32] &  (1 << (bit % 32));
}
//

// By default, Set all of memory is in use
void pmmngr_init () 
{
    mem_free_blocks=0;

    for(int i=0;i<mem_array_size;i++)
    {
	_mmngr_memory_map[i]=0xffffffff;
    }
}

//find the first free bit
int mmap_first_free () 
{
    for (int i=0; i< mem_array_size ; i++)
	if (_mmngr_memory_map[i] != 0xffffffff)
	    for (int j=0; j<32; j++) 
	    {		
		if(!mmap_test(32*i+j))return 32*i+j;
	    }
 
    return -1;
}

/*
//find the first free consecutive x bits
int mmap_first_free_s (uint32_t x) 
{
    int found=0;

    for (int i=0; i< mem_array_size; i++)
	if (_mmngr_memory_map[i] != 0xffffffff)
	    for (int j=0; j<32; j++)
	    {
		if(!mmap_test(32*i+j))found++;
		else found=0;
		if(found==x)return 32*i+j;
	    }

    return -1;
}
*/

void pmmngr_init_region (uint32_t  base, uint32_t size)
{
    uint32_t align = base / PMMNGR_BLOCK_SIZE;
    uint32_t blocks = size / PMMNGR_BLOCK_SIZE;

    for (; blocks>0; blocks--) 
    {
	mmap_unset (align++);
	mem_free_blocks++;
    }
}

void pmmngr_deinit_region (uint32_t  base, uint32_t size)
{
    uint32_t align = base / PMMNGR_BLOCK_SIZE;
    uint32_t blocks = size / PMMNGR_BLOCK_SIZE;

    for (; blocks>0; blocks--) 
    {
	mmap_set (align++);
	mem_free_blocks--;
    }
}

void* pmmngr_alloc_block () 
{
    int frame = mmap_first_free ();

    if (frame == -1)
    {
	panic(FOOLOS_MODULE_NAME,"OUT OF MEMORY (alloc_block)");
	return 0;	//out of memory
    }

    mmap_set (frame);
    mem_free_blocks--;

    uint32_t addr = frame * PMMNGR_BLOCK_SIZE;
    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"alloc block (%d) 0x%08X)",frame,addr);

    return (void*)addr;
}
/*

void* pmmngr_alloc_blocks (uint32_t size) 
{

    int frame = mmap_first_free_s (size);

    if (frame == -1)
    {
	panic(FOOLOS_MODULE_NAME,"OUT OF MEMORY (alloc_blocks)");
	return 0;	//out of memory
    }

    for (int i=0; i<size; i++)
    {
	mmap_set (frame+i);
	mem_free_blocks--;
    }

    uint32_t addr = frame * PMMNGR_BLOCK_SIZE;

    return (void*)addr;
}
*/

void pmmngr_free_block (void* p) 
{
    uint32_t addr = (uint32_t*)p;
    int frame = addr / PMMNGR_BLOCK_SIZE;
 
    if(mmap_test(frame))
    {
	mmap_unset (frame);
	mem_free_blocks++;
    }

    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_FINE,"free block (%d) 0x%08X)",frame,addr);
}


void mem_init(uint16_t *memmap,uint16_t entries)
{
    // log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"the memory map contains %d entries.",entries);

    // count available mem
    uint32_t total_mem=0, highest_end;

    //save pointer to memmap
    uint16_t *save=memmap;

    //print memory map and calc blocks.
    for(int i=0;i<entries;i++)
    {
	int mem=(memmap[4]+(memmap[5]<<16));
	uint32_t low_end=(((uint32_t)memmap[1])<<16)+memmap[0];
	uint32_t high_end=low_end+mem-1;


	#ifdef MEM_PRINT_MEMORYMAP
	log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"range:  0x%08x - 0x%08x (%s  %d KB)",
		low_end,high_end,memmap_type_to_string[memmap[8]-1],mem/1024);
	#endif

	//reclaimable OR usable
	if(memmap[8]==1||memmap[8]==3)
	{
	    total_mem+=mem;
	    highest_end=high_end;

	}

	memmap+=12; // next entry;
    }

    int blocks=highest_end/4096+1;
    mem_array_size=blocks/32+1;

    _mmngr_memory_map=0x500000;
    
    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Init bitmap for 0x%X blocks (size: %d bytes)",blocks,mem_array_size*4);

    pmmngr_init (); //clear memmap

    //restore pointer to memmap
    memmap=save;

    for(int i=0;i<entries;i++)
    {
	if(memmap[8]==1||memmap[8]==3)
	{
	    pmmngr_init_region(memmap[0]+(memmap[1]<<16),memmap[4]+((memmap[5])<<16));
	}
	memmap+=12;
    }
    
    // here is somewhere our kernel stuff.
    // reserve 4Mb (0x100000-0x500000) for kernel and ext2 img
    pmmngr_deinit_region(0x0,0x500000);

    // and here is the memory map that we JUST created!
    pmmngr_deinit_region(0x500000,mem_array_size*4+PMMNGR_BLOCK_SIZE);
    

    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Usable Mem: %d (0x%X) bytes. (~%d MB)",total_mem,total_mem,total_mem/1024/1024);
    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"Currently Free 4K blocks: %d blocks.",mem_free_blocks);

}

// analytics
void mmap_show_free ()
{

    int last_pos=0; 
    uint32_t last=_mmngr_memory_map[0];

    for (int i=1; i< mem_array_size ; i++)
    {
	if (_mmngr_memory_map[i] != last||i==mem_array_size-1)
	{

	    if(last==0)
	    {
		log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"%d -%d free",last_pos*32,i*32);
	    }
	    else if(last==0xffffffff)
	    {
		log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"%d -%d full",last_pos*32,i*32);
	    }
	    else
	    {
		log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"%d -%d some free",last_pos*32,i*32);
	    }

	   last_pos=i;
	   last=_mmngr_memory_map[i];


	}
    }

}