// ext2 minidriver
// based on osdev wiki article: http://wiki.osdev.org/Ext2



#include <stdbool.h>
#include <stdint.h>

#include "fs.h"
#include "ext2.h"

typedef struct ext2_superblock_struct
{
    uint32_t inodes_count;
    uint32_t blocks_count;
    uint32_t blocks_reserved_count;
    uint32_t inodes_unalloc_count;
    uint32_t blocks_unalloc_count;
    uint32_t superblock_number;
    uint32_t block_size;
    uint32_t fragment_size;
    uint32_t blocks_per_group;
    uint32_t fragments_per_group;
    uint32_t inodes_per_group;
    uint8_t skip[12]; // maybe we will look at these fields later...
    uint16_t ext2_sig; // 0xef5
    uint16_t fs_state; 
    uint16_t error_handle; 
    uint16_t version_minor;
    uint8_t skip2[8]; // maybe we will look at these fields later...
    uint32_t os_id;
    uint32_t version_major;
    uint16_t uid_reserved;
    uint16_t gid_reserved;
}ext2_superblock;

typedef struct ext2_superblock_ext_struct
{
    uint32_t first_inode;
    uint16_t size_inode;
    uint16_t blockgroup;

    uint32_t features_opt;
    uint32_t features_req;
    uint32_t features_write;

    uint32_t blkid[4];
    char    vol_name[16];
    char    last_path[64];
    uint32_t compression;
    uint8_t prealloc_files;
    uint8_t prealloc_dirs;
    uint8_t unused[2];
    uint32_t journalid[4];
    uint32_t journal_inode;
    uint32_t journal_device;
    uint32_t orpan_head;

}ext2_superblock_ext;

typedef struct ext2_blockgroup_desc_struct
{
    uint32_t addr_block_bitmap;
    uint32_t addr_inode_bitmap;;
    uint32_t addr_inode_table;
    uint16_t unalloc_blocks_count;
    uint16_t unalloc_inodes_count;
    uint16_t dir_count;
    uint8_t unused[14];
}ext2_blockgroup_desc;

typedef struct ext2_dir_struct
{
    uint32_t inode;
    uint16_t size;
    uint8_t name_length_low;
    uint8_t name_length_high;
    // name follows
}ext2_dir;

typedef struct ext2_inode_struct
{
    uint16_t permissions;
    uint16_t user_id;
    uint32_t size_low;
    uint32_t skip[4];
    uint16_t group_id;
    uint16_t hardlink_count;
    uint32_t disk_sectors;
    uint32_t flags;
    uint32_t os_specific;
    uint32_t direct_pointer[12];
    uint32_t indirect1;
    uint32_t indirect2;
    uint32_t indirect3;
    uint32_t gen_num;
    uint32_t later1; // will be implemented later by the fooldriver
    uint32_t size_high;
    uint32_t frag;
    uint32_t os_spec2[3];
}ext2_inode;


void ram_read(char *in,char *out,int size, int count)
{
    for(int i=0;i<size*count;i++)
    {
	out[i]=in[i];
    }

}

int ext2_check(uint8_t *ram)
{
    ext2_superblock super;
    ext2_superblock_ext super_ext;
    uint8_t *ptr=ram+1024;
    ram_read(ptr,&super,sizeof(super),1);

    if(super.ext2_sig!=0xef53){
	log(FOOLOS_MODULE_NAME,5,"addr: 0x%08X",ram);
	panic(FOOLOS_MODULE_NAME,"no ext2 signature found, where ram-image expected");
    }
}

ext2_inode ext2_get_inode(uint8_t *ram,int inode_num)
{

    // get basic shit from superblock!
    ext2_superblock super;
    ext2_blockgroup_desc desc;
    ext2_inode inode;

    uint8_t *ptr=ram+1024;
    ram_read(ptr,&super,sizeof(super),1);
    if(super.ext2_sig!=0xef53)
    {
	log(FOOLOS_MODULE_NAME,5,"addr: 0x%08X",ram);
	panic(FOOLOS_MODULE_NAME,"no ext2 signature found, where ram-image expected!");
    }

    int block_group=(inode_num-1)/super.inodes_per_group;

    // get descrtptor for our blockgroup!
    //TODO: only correct for 1024bytes/block. read more than one!!!
    int block_size=1024;
    int descriptor_start_block=2;

    ptr=ram+block_size*descriptor_start_block;
    ptr+=sizeof(desc)*block_group; // skip to our descriptor;

    ram_read(ptr,&desc,sizeof(desc),1); // read descriptor

    // read our inode;
    ptr=ram+block_size*desc.addr_inode_table;
    ptr+=128*((inode_num-1)%super.inodes_per_group);

    ram_read(ptr,&inode,sizeof(inode),1); //get inode 2 (rood-directory)

    return inode;

}

void* ext2_get_blockstart(void* start, uint32_t block_size, uint32_t block_idx)
{
    return (start+block_size*block_idx);
}

void* ext2_get_indirectstart(void *start, uint32_t block_size, uint32_t indirect1_idx, uint32_t block_idx)
{
    uint32_t *indirect_ptr=ext2_get_blockstart(start,block_size,indirect1_idx);
    void *ptr=ext2_get_blockstart(start,block_size,indirect_ptr[block_idx]); 
    return ptr;
}

void* ext2_get_indirectstart_double(void *start, uint32_t block_size, uint32_t indirect2_idx, uint32_t block_idx)
{

    //doubly indirect list
    uint32_t *dil=ext2_get_blockstart(start,block_size,indirect2_idx);

    int indirect1_idx=block_idx/(block_size/4);
    int idx=block_idx%(block_size/4);

    //log(FOOLOS_MODULE_NAME,5,"bl: %d : %d / %d",block_idx,indirect1_idx, idx);
    return ext2_get_indirectstart(start,block_size,dil[indirect1_idx],idx);
}

int ext2_inode_content(char *ram,int inode_nr,uint8_t *ramdest,int max)
{
    ext2_check(ram);
    ext2_inode inode=ext2_get_inode(ram,inode_nr);

    int pos=0;
    int block=0;
    int block_size=1024;
    int block_counter=0;
    uint8_t *ptr=ext2_get_blockstart(ram,block_size,inode.direct_pointer[0]); 
    int sum=0;
    int count=0;

    log(FOOLOS_MODULE_NAME,5,"Loading %d.%d bytes",inode.size_high, inode.size_low);

    if(inode.size_high>0)panic(FOOLOS_MODULE_NAME,"inode with high.size unsupported, i am sorry.");

    while(pos<inode.size_low) // TODO: use size high!
    {
	ramdest[pos]=*ptr;
		    
	sum = (sum >> 1) + ((sum & 1) << 15);
	sum+=(int)*ptr;
	sum&=0xffff;
	count++;

	ptr++;
	block_counter++;
	pos++;

	if(block_counter>=block_size)
	{
	    block++;

	    if(block<12)
	    {
	  	    ptr=ext2_get_blockstart(ram,block_size,inode.direct_pointer[block]);

	    }
	    else if(block-12<block_size/4)
	    {
	  	    ptr=ext2_get_indirectstart(ram,block_size,inode.indirect1,block-12);
	    }
	    
	    else if(block-12-block_size/4<1024/4*1024/4)
	    {
	  	ptr=ext2_get_indirectstart_double(ram,block_size,inode.indirect2,block-12-block_size/4);
	    }
	    else
	    {
		panic(FOOLOS_MODULE_NAME,"Triple Indirect Block Pointers not supported yet, file is too big to load, sorry!");
	    }
	    

	    block_counter=0;
	}

	

    }
    log(FOOLOS_MODULE_NAME,5,"Fool Check Sum: 0x%08X for %d bytes",sum,count);

}

int ext2_filename_to_inode_traverse(uint8_t *ram, char *path,int inode_start)
{
    bool final=false;

    // skip leading slashes
    while(*path=='/')path++;
    char *first=path;

    while(*path!='/'&&*path!=0)path++;
    char *last=path;

    if(*path==0)final=true;
    else(*path=0);

    log(FOOLOS_MODULE_NAME,20,"looking for %s '%s' in inode: %d",final?"file":"dir",first,inode_start);

    fs_dirent dirs[25];
    int count= ext2_read_dir(ram, inode_start,dirs,25); // get dir
    
    for(int i=0;i<count;i++)
    {
	if(!strcmp_l(first,dirs[i].name,0))
	{
	    log(FOOLOS_MODULE_NAME,20,"found: %s (%s)",first,dirs[i].type==FS_FILE_TYPE_DIR?"dir":"file");
	    if(final)return dirs[i].inode;
	    return ext2_filename_to_inode_traverse(ram,last+1,dirs[i].inode);
	}
	//log(FOOLOS_MODULE_NAME,5,"no match: %s",dirs[i].name);
    }


    log(FOOLOS_MODULE_NAME,5,"file not found!");
    return -1;
    

    
}
int ext2_filename_to_inode(uint8_t *ram, char *path)
{

    if(!strcmp_l(path,"/",0))return 2; // root is inode 2 by definition

    char buf[256];
    for(int i=0;i<256;i++)
    {
	buf[i]=path[i];
	if(buf[i]==0)break;
    }

    return ext2_filename_to_inode_traverse(ram,buf,2);
}

int ext2_read_dir(uint8_t *ram, int inode_nr,fs_dirent *dirs,int max)
{

    log(FOOLOS_MODULE_NAME,20,"read_dir : max: %d",max);
    ext2_inode inode=ext2_get_inode(ram,inode_nr);

    char buf[256];
    int block_size=1024;
    uint8_t *ptr=ram+block_size*inode.direct_pointer[0]; //TODO: use other pointers in future!

    int pos=0;
    int c=0;

    while(pos<inode.size_low) // use size high?
    {
	if(c==max)break;

	// read dir data
	ext2_dir dir;
	ram_read(ptr,&dir,sizeof(dir),1);

	// read name
	ptr+=sizeof(dir);
	ram_read(ptr,&buf,sizeof(char),dir.name_length_low);
	ptr+=dir.name_length_low;
	buf[dir.name_length_low]=0;

	// increment memory pointer and position
	ptr+=dir.size-8-dir.name_length_low;
	pos+=dir.size;

	// copy data over to dirs
	dirs[c].inode=dir.inode;

	ext2_inode inode_current=ext2_get_inode(ram,dir.inode);

	if(inode_current.permissions&0x4000)
	{
		dirs[c].type=FS_FILE_TYPE_DIR;
	}
	else
	{
		dirs[c].type=FS_FILE_TYPE_FILE;
	}

	int i=0;
	do{
	    dirs[c].name[i]=buf[i];
	    i++;
	}while(buf[i-1]!=0);

//	log(FOOLOS_MODULE_NAME,5,"name: %s\n",dirs[c].name);

	c++;

    }

    return c;

}