#define FOOLOS_MODULE_NAME "kernel"

#include "lib/logger/log.h"
#include "lib/int/stdint.h"
#include "lib/bool/bool.h"
#include "smp.h"

///////
// interrupt handler prototypes
// todo: move somewhere else!?
void int_clock_handler();
void int_kb_handler();
//void int_floppy_handler();

uint32_t read_eip();

volatile uint8_t proc;

void kernel_ap()
{
	uint32_t cpu_counter=0;
	uint32_t ebp;
	asm volatile("mov %%ebp,%0":"=r"(ebp));
	int proc=ebp-0xffffff;
	proc/=-0x400;
	while(1)PutString("%d", proc*100,580,0b1111100000000000, (cpu_counter++));
}
//
// KERNEL MAIN 

// this is the very heart of our operating system!
//

void kernel_main(uint32_t initial_stack, int mp)
{

    // catch the APs (Application Processors)
    if(mp==1)
    {
	uint32_t ebp=0xffffff-proc*0x400;
	proc++;

	asm volatile("mov %0, %%ebp"::"r"(ebp));
        asm volatile("mov %ebp, %esp");
        asm volatile("jmp kernel_ap");
    }

    proc=0;

    // move the foolfont and aps code before it gets overwritten!	
    uint8_t *source=0x16600;
    uint8_t *dest=0x80000;
    for(int i=0;i<2*512;i++)
    {
	dest[i]=source[i];
    }

    source=0x16400;
    dest=0x9000;
    for(int i=0;i<1*512;i++)
    {
	dest[i]=source[i];
    }

    // 
    // 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).
    //	* the address of our Fool-Font binary data.
    //
    //	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_physbase=vesa_init(0x8300,0x8400,0x7600);
    uint32_t vesa_physbase=vesa_init(0x8300,0x8400,0x80000);


    //
    // Print initial address of the esp stack pointer
    //

    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"initial esp: 0x%08X",initial_stack);


    //
    //  Setup PIC
    //
    //  Do we nee this when using APIC?
    //

    log(FOOLOS_MODULE_NAME,FOOLOS_LOG_INFO,"setting up PIC.");
    pic_setup();


    //
    // Configuring the PIT timer.
    //
    
    timer_init();


    //
    //	Memory Init
    //

    // we know that here, the bootloader placed the mamory map!
    mem_init(0x7c00+0x400,*((uint16_t *)(0x7c00+0x600)));

    //
    // Initialize other processors (run this before entering paged mode)
    //
    //	This currently uses the MP Floating Pointer Struct.
    //	Should support APCI in future too.
    //

    smp_processors procdata1;    
    smp_processors procdata2;    
    smp_processors procdata;    

    // try to find acpi tables
    bool succ_acpi=acpi_find(&procdata1);

    // fallback to mp tables
    bool succ_mp=mp_find(&procdata2);

    if(!succ_acpi&&!succ_mp)
	panic(FOOLOS_MODULE_NAME,"ACPI and MP search failed! I do not want to continue!");

    if(succ_acpi)procdata=procdata1;
    else procdata=procdata2;

    // multiprocessing!

    smp_log_procdata(&procdata1);
    smp_log_procdata(&procdata2);
    smp_start_aps(&procdata);
	

    /////////////////////


    // paging  (pass the vesa physbase address for identity mapping)
    vmem_init(vesa_physbase);


    //
    // Interrupts
    //

    // init and interrupt decriptor table 
    int_init(0x08);

    // set default interrupts
    int_install();

    // setup some custom interrupts
    // remember that we shifted all interrupts with the pic by 32

    // install PIT interrupt handler (irq 0 => 32)
    int_install_ir(32, 0b10001110, 0x08,&int_clock_handler);

    // install keyboard interrupt handler (irq 1 => 33)
    int_install_ir(33, 0b10001110, 0x08,&int_kb_handler);

    // install floppy interrupt handler (irq 6 => 38)
    //int_install_ir(38, 0b10001110, 0x08,&int_floppy_handler);

    // now we can enable interrupts back again
    x86_int_enable();

    //////////////////////

    //
    // Scan the PCI Bus
    // 
    // We are interested in the E1000 Network Adapter in particular
    // Its driver will be hopefully implemented one day ;)
    //

    pci_init();

    //
    // Initialize Floppy Disk
    //
    
    // floppy_init();


    // 
    // "Shell"
    //
    // Will process input from the keyboard but will be completely
    // redesigned soon.
    //
    
    shell_init();

    //
    // Initialize Multitasking
    //
    // For now this starts two tasks which are scheduled 
    // round robin style.
    //

     task_init();

    
    //
    // Just hang here. 
    //
    while(1)asm("hlt");
   

 
}