#include "kernel/kernel.h"
#include "log.h"
//http://wiki.osdev.org/GUI

#include <stdarg.h>
#include "kernel/mem.h"
#include "vesa.h"

#include "lib/printf/printf.h"


//#define FOOLSOS_SHOW_VESAMODES

static foolfont *deffont;
//static vbemodeinfo *VbeModeInfoBlock;

static int console_x;
static int console_y;

static int console_lines;
static int console_cols;

static uint8_t* buffer;
static uint8_t* physbase;

void PutConsoleNL();
void PutPixel(int x,int y, int color);

// we need to obtain this from somewhere else..
static uint32_t vesaXres;
static uint32_t vesaYres;
static uint32_t vesaPitch;
static uint32_t vesaBpp;
static uint32_t vesaAddr;

//static char buf[80][24];

void vesa_update_cursor(uint32_t col,uint32_t row)
{
    console_x=col;
    console_y=row;
}

// helper_funcs
/*
static void vesa_print_char_col(int x, int y, char c, char col_fg, char col_bg)
{
 //   uint16_t attrib = (col_bg << 4) | (col_fg & 0x0F);
 //   uint16_t* video_mem=(uint16_t *)SCR_VIDEOMEM+(x+y*SCR_REAL_WIDTH);
  //  *video_mem=c | (attrib << 8) ;
}
*/

// same colors as in screen.h
static uint32_t cols[] = {
    0x0,      // black
    0x0066cc, //blue
    0x009900, //green
    0x33ffff, //cyan
    0xff3333, //red
    0xcc00cc, //magenta
    0x994c00, //brown
    0xa0a0a0, //light gray
    0x404040, //dark gray
    0x3399ff, //light blue
    0x99ff33, //light green
    0x99ffff, //cyan light
    0xff9999, //red light
    0xff99ff, //magenta light
    0xffff00, //yellow
    0xffffff, //white
};

// glue func for terminal 
void vesa_console_put_char(uint8_t c,uint8_t color_bg, uint8_t color_fg, uint32_t x, uint32_t y)
{
//    print_char_col(x,y,c, color_bg, color_fg);
	//PutFont(c, console_x*10,console_y*12, cols[color_fg],cols[color_bg]);
	
	//PutFont(c, x*10,y*12, cols[color_bg],cols[color_fg]);
	PutFont(c, x*9,y*11, cols[color_bg],cols[color_fg]);

//	buf[console_x][console_y]=c;
	
//	console_x++;

//	#ifdef FOOLOS_CONSOLE_AUTOBREAK
//	if(console_x>=console_cols)PutConsoleNL();
//	#endif
}

void vesa_switch_buffers()
{
    for(int i=0;i<800*600*2;i++)physbase[i]=buffer[i];
}

void vesa_put_rect(int x, int y, int w , int h, int color)
{
    for(int i=x;i<x+w;i++)
	for(int j=y;j<y+h;j++)
	    PutPixel(i,j,color);
}

void vesa_clear_screen()
{
    vesa_put_rect(0,0,vesaXres, vesaYres, 0xffffff);
}

void vesa_set_physbase(uint32_t addr)
{
    vesaAddr=addr;
}

    // 
    // We want to get output to the screen as fast as possible!
    //
    // Our Fool-Boot-Loader did set up VESA already for us.
    // The desired VESA mode is hardcoded in [boot/mbr.asm].
    //
    // The [vesa_init(...)] function requires:
    //
    //	* the addresses of the vbeinfo struct
    //	* the address of the vbemodeinfo struct (for selected mode).
    //	* Fool Font loaded inside ramimage
    //
    //	The first two paramters are hardcoded in [boot/mbr.asm],
    //	while the last one is set in the Makefile. The font binary
    //	is integrated in the kernel image.
    //
    //  this function returns the physical base address of 
    //  our video memory 
    //
    
uint32_t vesa_init(multiboot_information *inf, foolfont *rawfont)
{
//inf->framebuffer_type

    vesaXres=inf->framebuffer_width;
    vesaYres=inf->framebuffer_height;
    vesaPitch=inf->framebuffer_pitch;
    vesaBpp=inf->framebuffer_bpp;
    vesaAddr=inf->framebuffer_addr;

    //the only functionallu important init lines! (rest is log)
    //VbeModeInfoBlock=mode;
    deffont=rawfont;
    console_x=0;
    console_y=0;

    int line_height=12;
    int col_width=10;
    console_lines=vesaYres/line_height;
    console_cols=vesaXres/col_width;

    //TODO dynamic (but need to sync with terminal!)
    console_cols=80;
    console_lines=24;
   /* 
    // vesa info
    klog("vbe version: 0x%x / video mode ptr: 0x%x 0x%x",
	    info->VbeVersion, info->VideoModePtr[1], info->VideoModePtr[0]);

    // vesa info on selected mode:
    klog("colors r:%d 0x%x g:%d 0x%x b:%d 0x%x",
	    mode->red_position,mode->red_mask, 
	    mode->green_position,mode->green_mask, 
	    mode->blue_position,mode->blue_mask);

    klog("res: %d * %d / banks: %d / attr: 0x%x",
	    mode->Xres, mode->Yres, mode->banks, mode->attributes);
    klog("bpp: %d / physbase: 0x%x",
	    mode->bpp,mode->physbase);

     // vesa modes
     // todo: take segment from vbeinfo!
#ifdef FOOLSOS_SHOW_VESAMODES
    uint16_t *modeptr=info->VideoModePtr[0];

    while(*modeptr!=0xffff&&*modeptr!=0)
    {
	klog("mode supported : 0x%X", (*modeptr));
	modeptr++;
    }
#endif
*/


    return vesaAddr;   
}


// TODO: what will happen in 24bit mode?
void PutPixel(int x,int y, int color)
{
    //do not write memory outside the screen buffer, check parameters against the VBE mode info
    if (x<0 || x>vesaXres|| y<0 || y>vesaYres) return;
    if (x) x = (x*(vesaBpp>>3)); // get bytes (divide by 8)
    if (y) y = (y*vesaPitch);
    //uint8_t *cTemp=VbeModeInfoBlock->physbase;
    uint8_t *cTemp=VMEM_FRAMEBUFFER;

    cTemp[x+y] =  (uint8_t)(color & 0xff);
    cTemp[x+y+1] = (uint8_t)((color>>8) & 0xff);
    cTemp[x+y+2] = (uint8_t)((color>>16) & 0xff);
}


void PutFont(char c, int x,int y, int color_fg,int color_bg)
{

    int fnt=0x126-0x20;

    if(c>=0x20&&c<=0x126)fnt=c-0x20;

    int posx, posy, sizex=8, sizey=10;

    for(posx=x;posx<x+sizex;posx++)
    {
		PutPixel(posx,y-1,color_bg);
    }
    for(posy=y;posy<y+sizey;posy++)
    {
		PutPixel(x-1,posy,color_bg);
    }

    for(posx=x;posx<x+sizex;posx++)
    {

	for(posy=y;posy<y+sizey;posy++)
	{
	    if(deffont[fnt].line[posy-y]&1<<(7-(posx-x)))
	    {
		PutPixel(posx,posy,color_fg);
	    }
	    else
	    {
		PutPixel(posx,posy,color_bg);
	    }

	}
    }

}

void PutString(char *str, int x,int y, int color, va_list va)
{

    char buff[256];
    tfp_sprintf(buff,str,va);
    str=buff;

    int i=x;
    while((*str)!=0)
    {
	PutFont(*str, i,y, color,0x0);
	i+=9; // spacing 
	str++;
    }

}

void PutConsoleChar(char c, int color)
{
	if(c=='\n')
	{
	    PutConsoleNL();
	    return;
	}
	//PutFont(c, console_x*10,console_y*12, color);
	console_x++;


	#ifdef FOOLOS_CONSOLE_AUTOBREAK
	if(console_x>=console_cols)PutConsoleNL();
	#endif
}

void PutConsole(char *str, int color)
{

    while((*str)!=0)
    {
	PutConsoleChar(*str,color);
	str++;
    }

}
void PutConsoleNL()
{
    console_y++;
    if(console_y<console_lines)return;

    for(int line=0;line<24;line++)
    {
	for(int j=0;j<console_cols;j++)
	{
//		buf[j][line]=buf[j][line+1];
//		PutFont(buf[j][line],j*10,line*12,0x33ff66,0);
//		PutFont(buf[j][line+1],j*10,line*12,0x33ff66,0);
	}
    }

    for(int i=0;i<console_cols;i++)
    {
	PutFont(' ',i*10,23*12,0x33ff66,0);
	//buf[i][23]=' ';
    }

    console_x=0;
    console_y--;
}

static int boxx;
static int boxy;
////////////////
void vesa_render()
{
    vesa_clear_screen();
    vesa_put_rect(100,100,vesaXres-200,vesaYres-200,0xff);
    vesa_put_rect(boxx-10,boxy-10,20,20,0x999999);

    boxx++;
//    boxy+=boxx;
    if(boxx>vesaXres-100)boxx=100;
  //  if(boxy>VbeModeInfoBlock->Yres-200)boxy=200;

    vesa_switch_buffers();
}

/*
void vesa_init_doublebuff()
{
    boxx=300;
    boxy=300;

    int blocks=800*600*2/4096+1;
    physbase=VbeModeInfoBlock->physbase;
    buffer=pmmngr_alloc_blocks(blocks);
    klog("Init buffer of %d blocks at 0x%08X",blocks,buffer);

    VbeModeInfoBlock->physbase=buffer;
}
*/