#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <fcntl.h>
#include <unistd.h>

#include "main.h"
#include "disk.h"
#include "config.h"

struct mem_inode_s * mem_inodes = NULL;
struct interval_s {
	int min;
	int max;
} uid_list[] = UID_LIST, gid_list[] = GID_LIST;

int is_inode(struct ext2_inode * ino)
{
	int i;

	if (ino->i_dtime)
		return 0;
	if (	ino->i_atime < (ATIME_MIN) || ino->i_atime >= (ATIME_MAX) ||
		ino->i_ctime < (CTIME_MIN) || ino->i_ctime >= (CTIME_MAX) ||
		ino->i_mtime < (MTIME_MIN) || ino->i_mtime >= (MTIME_MAX)
	)
		return 0;
	if (ino->i_size > (FILE_SIZE_MAX))
		return 0;
	if (!(ino->i_flags & S_IFDIR) && ino->i_links_count>(LINKS_COUNT_MAX))
		return 0;

	if (!(ino->i_block[0]))
		return 0;
	for (i=1; i<EXT2_N_BLOCKS; i++)
	{	if( ino->i_block[i]>=nr_blocks )
			return 0;
		if (!(ino->i_block[i]))
			break;
	}
	for (i++; i<EXT2_N_BLOCKS; i++)
		if (ino->i_block[i])
			return 0;
	for (i=0; uid_list[i].min != -1; i++)
		if (ino->i_uid>=uid_list[i].min && ino->i_uid<=uid_list[i].max)
			break;
	if (uid_list[i].min == -1)
		return 0;
	for (i=0; gid_list[i].min != -1; i++)
		if (ino->i_gid>=gid_list[i].min && ino->i_gid<=gid_list[i].max)
			break;
	if (gid_list[i].min == -1)
		return 0;
	return 1;
}

int is_inode_table( __u32 block )
{ int i;
	for(i=0;i<groups;i++)
	{	if( group_desc_block[i].bg_inode_table<=block && block<group_desc_block[i].bg_inode_table+blocks_per_inodetable )
		{	return(1);
		}
	}
	return(0);
}

int get_inode_nr( unsigned long long ofs )
{ unsigned long long b;
  int i;
	b=ofs/blocksize;
	for(i=0;i<groups;i++)
	{	if( group_desc_block[i].bg_inode_table<=b && b<group_desc_block[i].bg_inode_table+blocks_per_inodetable )
		{	return(
	i*inodes_per_group
	+( 	(ofs-b*blocksize)
		/sizeof(struct ext2_inode) )
	+((b-group_desc_block[i].bg_inode_table)
	  *(blocksize/sizeof(struct ext2_inode) ))+1);
		}
	}
fprintf(stderr,"\nInode found out of inode table (Don't panic;-)\n");
	return(EXT2_UNKNOWN_INO);
}

int find_inodes(int fd)
{
	struct mem_inode_s * p;
	char buf[1024*sizeof(struct ext2_inode)];
	int i, nr_inodes = 0;
	struct ext2_inode * inode;
	unsigned long long pos=0;

//printf("inodes_per_group=%d blocks_per_inodetable=%d groups=%d\n",inodes_per_group,blocks_per_inodetable,groups);
	progressbar_init("Finding inodes");
	lseek(fd, 0l, SEEK_SET);
	while ((i=read(fd, buf, sizeof(buf))) > 0) {
		progressbar_display( ((float)pos/((float)fs_size/100.)) , nr_inodes);
		for (inode=(struct ext2_inode *)buf; (void *)inode<(void *)(buf+i); inode++)
			if (is_inode(inode)) {
				p = (struct mem_inode_s *)malloc(sizeof(struct mem_inode_s));
				if (!p) {
					perror("Inode data loss; increase memory and/or swap");
					continue;
				}
				p->block=(pos+((char*)inode-(char*)buf))/blocksize;
				p->block_offset=((pos+((char*)inode-(char*)buf))-(p->block)*blocksize) /sizeof(struct ext2_inode);
				p->to_block=p->block;
				p->need_to_write=0;
				p->ok=0;
				p->indirect=NULL;
				memcpy(&(p->inode), (void *)inode, sizeof(struct ext2_inode));
				p->inode_nr = get_inode_nr(pos+((char*)inode-(char*)buf));
//printf("mam inode %ld \n",p->inode_nr);
				p->next = mem_inodes;
				mem_inodes = p;
				nr_inodes++;
				/* !!! mozno nacitat indirect bloky */
			}
		pos+=i;
	}
	progressbar_display( ((float)pos/((float)fs_size/100.)) , nr_inodes);
	progressbar_stop();
	return nr_inodes;
}



/* -------------------------- */

struct mem_inode_s *find_inode_by_number( int n )
{ struct mem_inode_s *p;
	for(p=mem_inodes;p!=NULL;p=p->next)
		if( p->inode_nr==n )
			return(p);
	return(NULL);
}

struct mem_inode_s *find_inode_by_firstblock( __u32 block )
{ struct mem_inode_s *p;
	for(p=mem_inodes;p!=NULL;p=p->next)
		if( p->inode.i_block[0]==block )
			return(p);
	return(NULL);
}

struct mem_inode_s *find_inode_by_direct_block( __u32 block )
{ struct mem_inode_s *p;
  int i;
	for(p=mem_inodes;p!=NULL;p=p->next)
		for(i=0;i<EXT2_NDIR_BLOCKS;i++)
			if( p->inode.i_block[i]==block )
				return(p);
	return(NULL);
}

int add_block_to_inode( struct mem_inode_s *inode, __u32 block )
{ int i;
	for(i=0;i<EXT2_NDIR_BLOCKS;i++)
		if( inode->inode.i_block[i]==0 )
		{	inode->inode.i_block[i]=block;
			inode->inode.i_blocks++;
			inode->inode.i_size+=blocksize;
			inode->need_to_write=1;
			return(1);
		}
	if( inode->indirect==NULL && inode->inode.i_blocks>EXT2_NDIR_BLOCKS+4 )
	{		fprintf(stderr,"Fatal error!!!!!!!!!\n");
			return(0);
	}
	if( inode->indirect==NULL )
	{	inode->indirect=malloc(sizeof(struct mem_inode_ind_s)+blocksize);
		inode->indirect->next=NULL;
		inode->indirect->level=1;
		inode->indirect->n=0;
		inode->indirect->to_block= get_free_block() ;
		inode->inode.i_block[EXT2_NDIR_BLOCKS]=inode->indirect->to_block;
		memset(&(inode->indirect->data[0]),0,blocksize);
	}
	if( inode->indirect->n < blocksize/4 )
	{	((__u32*)(&(inode->indirect->data[0])))[inode->indirect->n]=block;
		inode->inode.i_blocks++;
		inode->inode.i_size+=blocksize;
		inode->need_to_write=1;
		return(1);
	}
	/* !!! zeby este do indirect ? asi ano !!! */
	return(0);
}