#include "file_use.h"


//---------------------------------------------------------------------
void f_file_null( f_file *f_f )
{
	if ( f_f )
	{
		f_f->fid = NULL;
		f_f->flags = 0;
		f_f->size = -1;
		f_f->seek = -1;
	}
}


//---------------------------------------------------------------------
int f_file_seek( f_file *f_f, long offset, int seek )
{
	int ret=-1;
	PRINT("\n");
	if ( f_f )
	{
		if ( offset < 0 )
		{
			ERROR("\n");
			return -1;
		}

		if ( offset > f_f->size )
		{
			ERROR("\n");
			return -1;
		}
		
		
		ret = fseek( f_f->fid, offset , seek );
		PRINT("ret=%d\n",ret);
		if ( ret == 0 )
		{
			f_f->seek = ret;
		}
		else
		{
			ERROR("cannot seek to %d\n", offset);
			return -1;
		}
		PRINT("ret=%d\n",ret);
	}
	return ret;
}

//---------------------------------------------------------------------
size_t f_file_read( f_file *f_f, size_t size, void *ptr )
{
	size_t ret=-1;

	PRINT("\n");
	if ( f_f )
	{
		if ( (f_f->flags == F_FILE_READ) ||
			(f_f->flags == F_FILE_RW))
		{
			if ( f_f->size >= f_f->seek + f_f->size )
			{
				ret = fread( ptr, 1, size, f_f->fid );
				/*
				if ( ret != size )
				{
					ERROR("%d != %d\n", ret, size );
					return -1;
				}
				else
				*/
				if ( ret < 0 )
				{
					ERROR("\n");
					return ret;
				}
			} else
			{
				ERROR("\n");
			}
		} else
		{
			ERROR("file writable only");
		}
	}
	return ret;
}


//---------------------------------------------------------------------
//not effective algo ofcourse, but who cares while no one cares
//read buffer and then find in buffer newline, calc nl position and
//do the job
size_t f_file_readl( f_file *f_f, size_t size, void *ptr )
{
	size_t ret=-1;

	PRINT("\n");
	if ( f_f )
	{
		int c=0;
		size_t counter=0;
		//fseek( f_f->fid, 0, SEEK_SET);
		c = getc( f_f->fid );
		while ( (c != '\n') && ( c != EOF ))
		{
			if ( counter < size )
			{
				((char *)(ptr))[counter] = (char)c;
				counter++;
			}

			c = getc( f_f->fid );
		}
		if ( counter > 0 ) ret = counter;
	}

	return ret;
}

//---------------------------------------------------------------------
int f_file_size( f_file *f_f )
{
	int ret=-1;
	long old_seek;

	PRINT("\n");
	if ( f_f )
	{
		//could make some logic break
		if ( f_f->size < 0 )
		{
			old_seek = ftell( f_f->fid );
			fseek( f_f->fid, 0, SEEK_END );
			ret = ftell( f_f->fid );
			fseek( f_f->fid, old_seek, SEEK_CUR );
		}
	}
	return ret;
}


//f_file_read_bl();


//---------------------------------------------------------------------
size_t f_file_write( f_file *f_f, size_t size, void *ptr )
{
	PRINT("\n");
	if ( f_f )
	{
		if ((f_f->flags == F_FILE_WRITE) || 
			(f_f->flags == F_FILE_RW) )
		{
			ERROR("Not yet ready\n");
		}
	}
	
}


//f_file_write_bl();


//---------------------------------------------------------------------
f_file* f_file_open( const char *fname, int flags )
{
	f_file *ret = NULL;

	char *f_flags_write="r";
	char *f_flags_read="w";
	char *f_flags_rw="r+";
	char *f_flags_tmp=NULL;

	PRINT("\n");
	if ( fname != NULL )
	{
		ret = malloc( sizeof( f_file ) );
		if ( ret == NULL )
		{
			ERROR("Cannot alloc mem\n");
			return NULL;
		}
		memset( ret, 0, sizeof( f_file ));
		f_file_null( ret );
		switch ( flags )
		{
			case F_FILE_READ:
				f_flags_tmp = f_flags_read;
				ret->flags = F_FILE_READ;
				break;

			case F_FILE_WRITE:
				f_flags_tmp = f_flags_write;
				ret->flags = F_FILE_WRITE;
				break;
			
			case F_FILE_RW:
				f_flags_tmp = f_flags_rw;
				ret->flags = F_FILE_RW;
				break;

			default:
				ERROR("Unknown flag for opening \n");
				goto exit_close_f;
		}
		ret->fid = fopen( fname, "r" );
		if ( ret->fid == NULL )
		{
			ERROR("Cannot open file\n");
			goto exit_close_f;
		}
		ret->size = f_file_size( ret );
		fseek( ret->fid, 0, SEEK_SET );
	}
	return ret;

exit_close_f:
	if ( ret != NULL )
		free( ret );
	return NULL;
}


//---------------------------------------------------------------------
int f_file_close( f_file *f_f )
{
	PRINT("\n");
	if ( f_f )
	{
		fclose( f_f->fid );
		free( f_f );
		f_f = NULL;
	}
}