#include "kernel/kernel.h"
#include "log.h"
#include <stdint.h>
#include "ext2.h"
#include "elf.h"
#include "lib/string/string.h"

#define EI_NIDENT 16

typedef uint32_t Elf32_Addr;
typedef uint32_t Elf32_Off;
typedef uint16_t Elf32_Section;
typedef uint16_t Elf32_Versym;
typedef unsigned char Elf_Byte;
typedef uint16_t Elf32_Half;
typedef int32_t Elf32_Sword;
typedef uint32_t Elf32_Word;
typedef int64_t Elf32_Sxword;
typedef uint64_t Elf32_Xword;


typedef struct
{

        unsigned char   e_ident[EI_NIDENT];
        Elf32_Half      e_type;
        Elf32_Half      e_machine;
        Elf32_Word      e_version;
        Elf32_Addr      e_entry;
        Elf32_Off       e_phoff;
        Elf32_Off       e_shoff;
        Elf32_Word      e_flags;
        Elf32_Half      e_ehsize;
        Elf32_Half      e_phentsize;
        Elf32_Half      e_phnum;
        Elf32_Half      e_shentsize;
        Elf32_Half      e_shnum;
        Elf32_Half      e_shstrndx;

}
Elf32_Ehdr;


typedef struct {
       Elf32_Word      sh_name;
       Elf32_Word      sh_type;
       Elf32_Word      sh_flags;
       Elf32_Addr      sh_addr;
       Elf32_Off       sh_offset;
       Elf32_Word      sh_size;
       Elf32_Word      sh_link;
       Elf32_Word      sh_info;
       Elf32_Word      sh_addralign;
       Elf32_Word      sh_entsize;
} Elf32_Shdr;

typedef struct {

       Elf32_Word      p_type;
       Elf32_Off       p_offset;
       Elf32_Addr      p_vaddr;
       Elf32_Addr      p_paddr;
       Elf32_Word      p_filesz;
       Elf32_Word      p_memsz;
       Elf32_Word      p_flags;
       Elf32_Word      p_align;
} 
Elf32_Phdr;

void elf_multiboot_read(multiboot_information *info)
{
    uint32_t num=info->syms[0];
    uint32_t addr=info->syms[2];
    uint32_t stridx=info->syms[3];

    klog("ELF Kernel Sections:");
    // iterate over section headers. 
    Elf32_Shdr *shdr=addr;
    for(int i=0;i<num;i++)
    {
	uint32_t nameidx=shdr[i].sh_name;
	char *name=shdr[stridx].sh_addr+nameidx;
	klog("section %d: %s addr: 0x%08X offset: 0x%08X size: 0x%08X",i,name,shdr[i].sh_addr,shdr[i].sh_offset,shdr[i].sh_size);
    }
}

/** returns elf entry point ans et breakpoint to alloc */
uint32_t load_elf(char *name, uint32_t *alloc)
{
    uint32_t ext2_ramimage=VMEM_EXT2_RAMIMAGE;
    int inode_nr=ext2_filename_to_inode(ext2_ramimage,name);

    if(inode_nr<1)return 0;

    //TODO: load ELF binary and move this to own compilation unit
    
    //load binary
    uint32_t vaddr=0x08048000;
    uint32_t pos=0;

    klog("loading %s",name);
    ext2_read_inode(ext2_ramimage,inode_nr,vaddr,&pos,4096*VMEM_USER_PROG_PAGES); // max ignored??

    klog("ELF File loaded to final destination.");
    Elf32_Ehdr *elf;
    elf=vaddr;

    if(elf->e_ident[0]!=0x7f||elf->e_ident[1]!='E'||elf->e_ident[2]!='L'||elf->e_ident[3]!='F')
	kpanic("ELF mismatch!?");

    
    /*
    klog( 
	    "elf id: class=%d, data=%d, version=%d osabi=%d abiv=%d ",
	    elf->e_ident[4],elf->e_ident[5],elf->e_ident[6],
	    elf->e_ident[7],elf->e_ident[8]);

    klog("elf type: 0x%04x",elf->e_type);
    klog("elf machine: 0x%04x",elf->e_machine);
    klog("elf version: %d",elf->e_version);
    klog("elf entry: 0x%08X",elf->e_entry);
    klog("elf ph-offset: 0x%08X",elf->e_phoff);
    klog("elf sh-offset: 0x%08X",elf->e_shoff);
    klog("elf flags: 0x%08X",elf->e_flags);
    klog("elf eh-size (bytes): %d",elf->e_ehsize);

    klog("elf ph-ent-size(bytes): %d",elf->e_phentsize);
    klog("elf ph-num: %d",elf->e_phnum);

    klog("elf sh-ent-size(byte): %d",elf->e_shentsize);
    klog("elf sh-num: %d",elf->e_shnum);

    klog("elf sh-strndx: %d",elf->e_shstrndx);
    */

    // iterate over section headers
    for(int phidx=0;phidx<elf->e_phnum;phidx++)
    {	
	Elf32_Phdr *phdr=vaddr+elf->e_phoff+phidx*elf->e_phentsize;
	    klog("-- PROGRAMM HEADER %d --",phidx+1);
	    klog("p-type: %d",phdr->p_type);
	    klog("p-offset: 0x%08X",phdr->p_offset);
	    klog("p-vaddr: 0x%08X",phdr->p_vaddr);
	    klog("p-filesz: 0x%08X",phdr->p_filesz);
	    klog("p-memsz: 0x%08X",phdr->p_memsz);


	if(phidx==0)
	{
	    klog("text: 0x%08X-0x%08X",phdr->p_vaddr,phdr->p_vaddr+phdr->p_filesz);
	}

	if(phidx==1)
	{


	    
	    klog("data: 0x%08X-0x%08X",phdr->p_vaddr,phdr->p_vaddr+phdr->p_filesz);
	    klog("bss: 0x%08X-0x%08X",phdr->p_vaddr+phdr->p_filesz,phdr->p_vaddr+phdr->p_memsz);

	    // let's copy the rw- data block
	    // from right to left so we not overwrite ourselves!!
	    
	    //for(uint8_t *addr=phdr->p_vaddr; addr<=phdr->p_vaddr+phdr->p_filesz; addr++) // this was wrong!
	    //uint8_t *data=vaddr+phdr->p_offset;
	    uint8_t *data=vaddr+phdr->p_offset+phdr->p_filesz-1;
	    
	    for(uint8_t *addr=phdr->p_vaddr+phdr->p_filesz-1; (uint32_t)addr>=phdr->p_vaddr; addr--)
	    {
		*addr=*data;
		data--;
	    }

	    // let's zero init bss and set alloc (heap) just right after it! 
	    for(uint8_t *addr=phdr->p_vaddr+phdr->p_filesz; (uint32_t)addr<=phdr->p_vaddr+phdr->p_memsz; addr++)
	    {
		*addr=0;
	    }

	    *alloc=phdr->p_vaddr+phdr->p_memsz;
	}

    }
    klog("heap starts at: 0x%08X",*alloc);
    klog("entry point: 0x%08X",elf->e_entry);

    return elf->e_entry;
}