#include "ihe.h"
#include "core.h"

static int cmd_loop = 1;
extern cmd_table_t tab[];

#define CMK_KEYMAP1(KEY) (in_buf[0]==(KEY)&&(ret_read==1))

#define CMD_IN_BUF_SIZE 32
typedef struct cmd_in_buf_t
{
	char buf[CMD_IN_BUF_SIZE+2];//enought space to put "'\n',NULL"
	int cur_sz;
} cmd_in_buf_t;

int cmd_buf_clean( cmd_in_buf_t *buf );
/* 
type == 1, usual printable chars 
type == 2, print in hex   
*/
int cmd_buf_print( cmd_in_buf_t *buf, int type );
int cmd_buf_add( cmd_in_buf_t *buf, char *ch, int size );

int cmd_buf_clean( cmd_in_buf_t *buf )
{
	memset( buf, 0, sizeof(cmd_in_buf_t));
	return 0;
}


int cmd_buf_print( cmd_in_buf_t *buf, int type )
{
	int i;
	//printf("sz:%d\n",buf->cur_sz);
	for (i=0;(i<buf->cur_sz)&&(i<CMD_IN_BUF_SIZE);i++)
	{
		if (type == 1)
		{
			if (isprint(buf->buf[i]))
			{
				printf("%c",(char)(buf->buf[i]&0xff));
			} else
			{
				printf(".");
			}
		} else if (type == 2)
		{
			printf("%02x ", (unsigned char)(buf->buf[i]&0xff) );
		}
	}
	printf("\n");
	return 0;
}

int term_set_std_mode( term_screen *ts )
{
	int ret = 0;

	if ( tcgetattr( ts->ifd, &ts->orig_i ) == -1 )
	{
		ERROR("Cannot get input terminal attributes\n");
		goto exit_error;
	}

	ts->raw_i = ts->orig_i; /* modify the original mode */
	/* input modes: no break, no CR to NL, no parity check, no strip char,
	 * no start/stop output control. */
	//ts->raw_i.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
	ts->raw_i.c_iflag = IUTF8|ICRNL;
	/* output modes - disable post raw */
	//ts->raw_i.c_oflag &= ~(OPOST);
	ts->raw_i.c_oflag = OPOST|ONLCR;
	/* control modes - set 8 bit chars */
	//ts->raw_i.c_cflag |= (CS8);
	ts->raw_i.c_cflag = CS8|CREAD;
	/* local modes - choing off, canonical off, no extended functions,
	 * no signal chars (^Z,^C) */
	//ts->raw_i.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
	//if ICANNON ignore ESC char
	//ts->raw_i.c_lflag = ISIG|ECHO;
	ts->raw_i.c_lflag = ISIG;
	/* control chars - set return condition: min number of bytes and timer.
	 * We want read to return every single byte, without timeout. */
	ts->raw_i.c_cc[VMIN] = 1; 
	ts->raw_i.c_cc[VTIME] = 0; /* 1 byte, no timer */

	/* put terminal in raw mode after flushing */
	if (tcsetattr( ts->ifd, TCSAFLUSH, &ts->raw_i) < 0)
	{
		ERROR("Cannot set new terminal input attribures\n");
		goto exit_error;
	}

	return ret;

exit_error:
	errno = ENOTTY;
	return -1;

}


int custom_term_echo( char *keybuf )
{
	if (isprint(keybuf[0]))
	{
		write(1,keybuf,1);
	}
	if (keybuf[0]=='\n')
	{
		write(1,"\r\n",2);
	}
	return 0;
}


int cmd_tab_autocomplete( char *in_buf )
{
	cmd_arg_t *args;
	cmd_tok_t tl, *ptr = &tl, *iter = NULL;
	struct cmd_acq_t *iter_sugg = NULL;
	memset( &tl, 0, sizeof( cmd_tok_t ));
	//int i;

	//printf("[%s]\n", in_buf);
	if ( parse_cmd( ptr, in_buf) == -1)
	{
		printf("Cmd problems\n");
		return -1;
	}

	iter = ptr->next;
	args = cmd_arg_create( iter );

	/*
	for (i=0; i<args->argc; i++)
	{
		printf("ARG:%d TYPE:%d %s\n", i, args->type[i], args->argv[i]);	
	}
	*/

	//printf("Unkn command\n");
	//if command not found offer auto complete options
	if (args->argc > 0) 
	{
		//printf("asd\n");
		struct cmd_acq_head_t *ac = cmd_acq(tab,args->argv[0]);
		if (ac != NULL)
		{
			//printf("Did you mean ");
			SLIST_FOREACH(iter_sugg,ac,next_sugg)
			{
				printf("%s ", iter_sugg->suggestion);
			}
			printf("\n");
		}
		cmd_acq_free( ac );
	}

	cmd_tok_destroy( ptr->next );
	ptr->next = NULL;
	cmd_arg_destroy( args );

	return 0;
}


int cmd_buf_add( cmd_in_buf_t *buf, char *ch, int size )
{
	int i,j;

	/*
	for (i=0;i<size;i++)
	{
		printf("|%c|",ch[i]);
	} printf("\n");
	*/

	i=buf->cur_sz;
	for ( j=0;
		j<size;
		j+=1 )
	{
		if ( (i+j) < CMD_IN_BUF_SIZE )
		{
			//printf("%d %c",(i+j),ch[j]);
			buf->buf[i+j] = ch[j];
			buf->cur_sz = i+j+1;
			//printf("%d\n", buf->cur_sz );
			//printf("\n");
		}
	}

	return 0;
}

/*
				GLOBAL VARIABLES
 */
static file_t *g_file = NULL;
static buf_t *g_buf = NULL;
static int g_flags = FD_RW;


int c_version( cmd_arg_t *arg )
{
	int argc = arg->argc;

	if ( argc != 0 )
	{
		printf("Command should not have arguments mister\n");
		return -1;
	}

	printf("Version 0.0.2\n");

	return 0;
}


int c_arg(  cmd_arg_t *arg  )
{
	int i;
	int argc = arg->argc;
	char **argv = arg->argv;

	for (i=0;i<argc;i++)
	{
		printf("arg %d: val :%s\n", i, argv[i]);
	} 

	return 0;
}


int c_quit(  cmd_arg_t *arg  )
{
	cmd_loop = 0;
	return 0;
}


int c_help(  cmd_arg_t *arg  )
{
	int i = 0;
	printf("Command list\n");
	while ( tab[i].cmd != NULL )
	{
		printf("%s - \n", tab[i].cmd);
		i++;
	}
	return 0;
}


/*
OPEN <FILENAME>
*/
int c_open(  cmd_arg_t *arg  )
{

	int argc = arg->argc;
	char **argv = arg->argv;
	char *fname = NULL;
	int fret = 0;

	if ( argc != 1 )
	{
		printf("Neeed one argument\n");
		return -1;
	}

	fname = argv[0];

	fret = file_open_fn( g_file, fname, g_flags ); //!if failure fields could be non empty inside struct
	if ( fret < 0 )
	{
		printf("Cannot open file %s\n",fname);
		return -1;
	}



	return 0;
}


/*
CLOSE
*/
int c_close(  cmd_arg_t *arg  )
{
	int fret = 0;

	fret = file_close( g_file );
	if ( fret != 0 )
	{
		printf("Cannot close file\n");
		return -1;
	}

	return 0;
}


/*
FILE
*/
int c_info(  cmd_arg_t *arg  )
{

	if ( g_file == NULL )
	{
		printf("no opened files\n");
	} else
	{
		printf("FILE INFO:\n");
		printf("NAME    : %s\n", g_file->filename );
		printf("FD      : %d\n", g_file->fd );
		printf("FLAGS   : 0x%08x\n", g_file->flags );
		printf("MODE    : 0x%08x\n", g_file->mode );
		printf("OFFSET  : %zd\n", g_file->offset );
		printf("POSITION: %ld\n", g_file->position );
		printf("SIZE    : %zd\n", g_file->size );
		printf("BLOCK   : %u\n", g_file->blk_size );
	}

	if ( g_buf == NULL )
	{
		printf("buffer not initialised\n");
	} else
	{
		printf("BUF:\n");
		printf("ADDR   : %p\n", g_buf->buf);
		printf("SIZE   : %d\n", g_buf->size);
		printf("BUFSIZE: %d\n", g_buf->buf_size);
	}

	return 0;
}


int c_seek(  cmd_arg_t *arg  )
{
	int fret;
	int argc = arg->argc;
	char **argv = arg->argv;
	off_t offset;
	int off_type = 0; //-1 seek down, 0 set pos, +1 seek up

	if (argc != 1)
	{
		printf("One argument needed\n");
		return -1;
	}

	if (g_file->fd == 0)
	{
		printf("File descriptor not set\n");
		return -1;
	}

	//set seek type
	switch( argv[0][0] )
	{
	case '+':
		off_type = 1;
		break;
	case '-':
		off_type = -1;
		break;
	default:
		off_type = 0;
	}

	offset = atoi( argv[0] ); //!fix that to strtol at least

	if (off_type == 0)
	{
		//g_file offset maybe wrong
		fret = file_seekp( g_file, offset );
	} else
	{
		fret = file_seek( g_file, offset );
	}
	if ( fret != 0 )
	{
		printf("Cannot seek postion to %zd\n", offset);
		return -1;
	}

	return 0;
}


int c_pos(  cmd_arg_t *arg )
{
	int fret = 0;

	fret = file_pos( g_file );
	if ( fret < 0)
	{
		printf("Cannot get file position\n");
		return -1;
	}

	printf("POS:%d\n",fret);

	return 0;
}


int c_size( cmd_arg_t *arg  )
{
	off_t size;

	size = file_size( g_file );
	if ( size < 0 )
	{
		printf("Cannot get file size\n");
		return -1;
	}

	printf("File size %zu\n", size);

	return 0;
}


int c_blk( cmd_arg_t *arg )
{
	printf("FILE BLOCK SIZE %u\n", g_file->blk_size );
	printf("BUFFER BLOCK SIZE %d (MAX %d)\n", g_buf->size, g_buf->buf_size );

	return 0;
}


int c_read( cmd_arg_t *arg )
{
	int ret;

	if ( g_buf->buf == NULL )
	{
		printf("Buffer mem not allocated\n");
		return -1;
	}

	ret = file_read_blk( g_file, g_buf->buf );
	printf("Readed %d bytes\n", ret);
	if ( (ret >= 0) && (ret <= g_buf->buf_size) )
	{
		g_buf->size = ret;
	}

	return 0;
}


int c_dump( cmd_arg_t *arg )
{
	int i;

	if ( g_buf->buf == NULL)
	{
		printf("Buffer to print empty\n");
		return -1;
	}

	for (i=0; i<g_buf->size; i++)
	{
		printf("%02x",(unsigned char)g_buf->buf[i]);
	}
	printf("\n");

	return 0;
}


int c_dumpx( cmd_arg_t *arg )
{
	int i,j;

	if ( g_buf->buf == NULL)
	{
		printf("Buffer to print empty\n");
		return -1;
	}

	for (i=0; i<g_buf->size; i+=16)
	{
		for (j=i; j<i+16; j++)
		{
			if ( j<g_buf->size )
			{
				printf("%02x ",(unsigned char)g_buf->buf[j]);
			} else
			{
				printf("   ");
			}
		}

		for (j=i; j<i+16; j++)
		{
			if ( j<g_buf->size ) //wrong place move to cycle?
			{
				if ( isprint(g_buf->buf[j]) )
				{
					printf("%c",(unsigned char)g_buf->buf[j]);
				} else
				{
					printf("\e[7m.\e[0m");
				}
			}
		}
		printf("\n");
	}
	printf("\n");

	return 0;
}


int c_dumps( cmd_arg_t *arg )
{
	int argc = arg->argc;
	char **argv = arg->argv;
	int i=0;

	if ( argc != 0 )
	{
		printf("No arguments plz\n");
		return -1;
	}

	for (i=0; i<g_buf->size; i++)
	{
		if (isprint(g_buf->buf[i]))
		{
			printf("%c", g_buf->buf[i]);
		} else
		{
			printf("\e[7m.\e[0m");
		}
	}
	printf("\n");

	return 0;
}


//support masks
int c_write( cmd_arg_t *arg)
{
	/*
	anonymous function
	*/
	uint8_t hex2u8( uint8_t *buf )
	{
		uint8_t ret = 0x00;
		unsigned long int uli;
		char str[3];
		str[0] = buf[0];
		str[1] = buf[1];
		str[2] = 0;

		uli = strtoul( str, NULL, 16 );

		ret = uli;

		return ret;
	}

	int argc = arg->argc;
	char **argv = arg->argv;
	int i;
	uint8_t *buf = NULL;
	int fret;

	if ( argc != 1 )
	{
		printf("One argument needed\n");
		return -1;
	}

	if ( (strlen(argv[0])%2) != 0 )
	{
		printf("Input string should be ( str mod 2 == 0) \n");
		return -1;
	}

	for (i=0;i<strlen(argv[0]);i++)
	{
		if ( !isxdigit(argv[0][i])  )
		{
			printf("CH %c not hexlike at pos %d\n", argv[0][i], i);
			return -1;
		}
	}

	if (strlen(argv[0]) > g_buf->size*2)
	{
		printf("Input param bigger then buffer\n");
		return -1;
	}

	
	for (i=0; i<strlen(argv[0]); i+=2)
	{
		printf("%02x ",(unsigned char)hex2u8((unsigned char*)&argv[0][i]));
	}
	printf("\n");
	

	buf = malloc(strlen(argv[0])/2);
	for (i=0; i<(strlen(argv[0])/2); i++)
	{
		buf[i] = hex2u8((unsigned char*)&argv[0][i*2]);
	}

	memcpy( g_buf->buf, buf, strlen(argv[0])/2 );
	fret = file_write_blk( g_file, g_buf->buf );
	free( buf );

	if ( fret < 0)
	{
		printf("Couldnt write block to file\n");
		return -1;
	}

	return 0;
}


//white spaces should be supported
int c_writes( cmd_arg_t *arg )
{
	int argc = arg->argc;
	char **argv = arg->argv;
	int fret = 0;

	if ( argc != 1)
	{
		printf("Need one argument mister\n");
		return -1;
	}

	if (((g_buf == NULL) || (g_file == NULL)) || (g_buf->buf == NULL))
	{
		printf("Buffer or file not initialised");
		return -1;
	}

	if ( strlen(argv[0]) <= g_buf->size )
	{
		memcpy( g_buf->buf, argv[0], strlen(argv[0]) );
		fret = file_write_blk( g_file, g_buf->buf );
		if ( fret < 0 )
		{
			printf("Couldnt write block to file\n");
			return -1;
		}
	} else
	{
		printf("Input bigger then buffer buf %d input %zu\n", g_buf->size, strlen(argv[0]));
		return -1;
	}

	return 0;
}


int c_flags( cmd_arg_t *arg )
{
	int argc = arg->argc;
	char **argv = arg->argv;

	if ( argc == 0 )
	{
		printf("FLAGS: 0x%08x\n", g_flags );
		return 0;
	}

	if ( argc > 1 )
	{
		printf("Only one argument needed\n");
		return -1;
	}

	if ( strncmp(argv[0],"R",2) == 0 )
	{
		g_flags = FD_RO;
	} else if ( strncmp(argv[0],"W",2) == 0 )
	{
		g_flags = FD_WO;
	} else if ( strncmp(argv[0],"RW",3) == 0 )
	{
		g_flags = FD_RW;
	} else
	{
		printf("Unknown mode. Suported R/W/RW\n");
		return -1;
	}

	return 0;
}


int c_manifesto( cmd_arg_t *arg )
{
	printf("""\
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\
+                                  MANIFESTO                                   +\n\
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\
+ 1. All hardware and software that you are owner of belongs to you no software+\n\
+    neither hardware patents can stop you to reverse engineer your property.  +\n\
+    Software/Hardware that you are owning should be obtained in legal way     +\n\
+    except situation under chapter 7                                          +\n\
+ 2. Any license or patent that disagree with that is unlawfull as it against  +\n\
+    to personal freedomes.                                                    +\n\
+ 3. Any compiled or non compiled code on your device is your property.        +\n\
+ 4. This software is made for any kind of knowledge gaining about software or +\n\
+    hardware that are belong to you. No commercial distribution of gained     +\n\
+    knowledge should be made. Only free knowledge distribution allowed.       +\n\
+ 5. This software should not be used to harm any living been this doesnt apply+\n\
+    to intelectual property of any kind. With this software personal info like+\n\
+    adresses, credit cards numbers, names, surnames, passwords should not be  +\n\
+    gained as it may harm living beans that owns them and surands them.       +\n\
+ 6. This software is made to explore system, gain understanding of system and +\n\
+    protect from system.                                                      +\n\
+ 7. This software may be used even if any patented or licensed                +\n\
+    hardware/software is used in hardware or software that may treat human    +\n\
+    life (rockets, warships, missles, army robots, electronics optical        +\n\
+    devices, guns, SCADA malware and so on) physicaly doesnt belong to this   +\n\
+    software user but treatening this software user life.                     +\n\
+ 8. By using this software you take all responsibity of result that may occure+\n\
+    while you use it on yourself.                                             +\n\
+ 9. THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR+\n\
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  +\n\
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL   +\n\
+    THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER+\n\
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING   +\n\
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER       +\n\
+    DEALINGS IN THE SOFTWARE.                                                 +\n\
+ 10. If you disagree with any point that mentioned here please stop using this+\n\
+    peace of software.                                                        +\n\
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n\
""");
	return 0;
}


int c_ls( cmd_arg_t *arg )
{
	int argc = arg->argc;
	//char **argv = arg->argv;
	uint8_t **f_ls = NULL;
	int i=0;

	if (argc > 0)
	{
		printf("Plz dont use arguments\n");
		return -1;
	}

	f_ls = dir_list("./");
	if ( f_ls == NULL )
	{
		printf("Cannot list current directory\n");
		return -1;
	}

	i = 0; 
	while ( f_ls[i] != NULL )
	{
		printf("%s\n",f_ls[i]);
		free( f_ls[i] );
		i++;
	}
	free( f_ls );

	return 0;
}

int c_pwd( cmd_arg_t *arg )
{
	int argc = arg->argc;
	//char **argv = arg->argv;
	char *cur_dir;

	if ( argc > 0 )
	{
		printf("PLZ no arguments\n");
		return -1;
	}

	cur_dir = get_current_dir_name();
	if ( errno != 0 )
	{
		printf("Cannot get current dir\n");
		free( cur_dir ); //on failure content unknown;
		return -1;
	}

	printf("%s\n", cur_dir);
	free( cur_dir );
	cur_dir = NULL;

	return 0;
}


int c_cd( cmd_arg_t *arg )
{
	int argc = arg->argc;
	char **argv = arg->argv;
	int fret = -1;

	if ( argc != 1 )
	{
		printf("Only 1 argument needed\n");
		return -1;
	}

	//printf("[%s]\n", argv[0]);
	fret = chdir( argv[0] );
	if ( fret == -1 )
	{
		printf("Cannot set dir to %s\n", argv[0]);
		return -1;
	}

	return 0;
}


int c_th( cmd_arg_t *arg )
{
	/*
	int argc = arg->argc;
	int th = -1;

	if ( argc > 0 )
	{
		printf("No arguments needed\n");
		return -1;
	}

	th = term_cur_get_r();
	if (th == -1)
	{
		printf("Cannot get current term height\n");
		return -1;
	}
	printf("%d\n",th);
	*/

	return 0;
}


int c_tw( cmd_arg_t *arg )
{
	/*
	int argc = arg->argc;
	int tw = -1;

	if ( argc > 0 )
	{
		printf("No arguments needed\n");
		return -1;
	}

	tw = term_cur_get_c();
	if (tw == -1)
	{
		printf("Cannot get current term width\n");
		return -1;
	}
	printf("%d\n",tw);
	*/

	return 0;
}
/*
CMD COMMANDS
*/
cmd_table_t tab[] = {
	/*
	{"version",   c_version },
	{"arg",       c_arg },
	{"quit",      c_quit},
	{"help",      c_help},
	{"?",         c_help},
	{"open",      c_open},
	{"close",     c_close},
	{"info",      c_info},
	{"seek",      c_seek},
	{"pos",       c_pos},
	{"size",      c_size},
	{"blk",       c_blk},
	{"read",      c_read},
	{"dump",      c_dump},
	{"dumpx",     c_dumpx},
	{"dumps",     c_dumps},
	{"write",     c_write},
	{"writes",    c_writes},
	{"flags",     c_flags},
	{"manifesto", c_manifesto},
	{"ls",        c_ls},
	{"pwd",       c_pwd},
	{"cd",        c_cd},*/
	//{"th",        c_th},
	//{"tw",        c_tw},
	{NULL, NULL }
};



int main( int argc, char **argv )
{
	const int sz_buf = 1024;
	uint8_t in_buf[sz_buf];
	int ret_read;
	int new_c=0, new_r=0, old_r=0, old_c=0;

	//preapre global stuff
	g_file = file_init();

	//init basic buffer 
	g_buf = buf_init();
	buf_size( g_buf, DEFAULT_BLK_SIZE );


	struct term_screen ts; memset( &ts, 0, sizeof(ts) );

	cmd_in_buf_t cmd_in;
	cmd_buf_clean( &cmd_in );

	if ( term_init( &ts ) == -1 )
		printf("Some err when init\n");

	//term_set_raw_mode( &ts );
	term_set_std_mode( &ts );

	term_clr_scr( &ts );

	new_c = term_get_maxcol( &ts );
	new_r = term_get_maxrow( &ts );
	old_r = new_r;
	old_c = new_c;

	term_cur_set_c( &ts, 0);
	term_cur_set_r( &ts, old_r);

	while ( 1 == 1 )
	{
		
		ret_read = read(2, in_buf, sz_buf );
		if (ret_read < 0)
		{
			printf("Cannot read\n");
			continue;
		}
		in_buf[ret_read] = 0;

		//custom echoing service to ignore some special chars like TAB
		custom_term_echo( (char *)in_buf );

		//printf("(%d)%s\n",ret_read,in_buf);
		if ( (isprint(in_buf[0])) && (in_buf[0]!='?') && (in_buf[0]!='\t'))
		{
			//printf("asd %d\n", ret_read);
			cmd_buf_add( &cmd_in, (char *)in_buf, ret_read );
		}

		//auto complete advice
		if (CMK_KEYMAP1(9))
		{
			//cmd_buf_print( &cmd_in, 2 );
			cmd_in.buf[cmd_in.cur_sz] = '\n';
			cmd_in.buf[cmd_in.cur_sz+1]   = 0;
			cmd_tab_autocomplete( cmd_in.buf );
			cmd_buf_print( &cmd_in, 1 );
			continue;
		}

		if (CMK_KEYMAP1('?'))
		{
			cmd_buf_print( &cmd_in, 1 );
		}

		if (CMK_KEYMAP1(27))
		{
			cmd_buf_print( &cmd_in, 1 );
			break;
		}

		if (CMK_KEYMAP1('\n'))
		{
			cmd_buf_clean( &cmd_in );
		}
		
	}

	term_clr_scr( &ts );

	term_set_orig_mode( &ts );

	return 0;
}