#include "arg.h"

//for local usage only?
int   __search_arg( char *in, def_arg *arg );
void* __create_arg( int type, void *val );
int   __add_arg( arg_t *arg, int type,void *val );


#define CHK_ARG(ARG,NUM) if ((ARG+NUM)>=argc) {\
printf("not enought arguments for %s ",argv[ARG]);break;} 

arg_t* arg_load( int argc, char **argv, def_arg *argl  )
{
	arg_t *ret = NULL;
	uint8_t *used; //count unused arguments, there should be no unused 
	            //elements at the end
	int i = 0;
	int pos = -1; //position of argv inside def_arg table
	void *arg_def_val = NULL;

	//prepare return value
	ret = malloc( sizeof(arg_t) );
	memset( ret, 0, sizeof(arg_t) );

	used = malloc(sizeof(uint8_t)*argc);
	memset( used, 0, sizeof(uint8_t)*argc );

	i = 1; //we can ignore first as first arg is name of programm
	while ( i < argc )
	{
		//printf("%s ",argv[i]);
		pos = __search_arg(argv[i], argl);
		//printf("TAB:%d\n", pos );

		switch (argl[pos].type)
		{
		case ARGT_NONE:
		{
			//printf("No arg\n");
			break;
		}
		case ARGT_IP:
		{
			//printf("%d is ip\n",i);
			/*
			arg_ip *ip = __create_arg( argl[i].type, argl[i].def );

			//if ip is 0.0.0.0 then probably no default value for ip
			if ( ((s_arg_ip*)argl[i].def)->ip == 0 )
				ip->def = 0;
			//ip->ptr = argv[i+1];
			ip->used = 1;
			i+=1;
			*/
			break;
		}
		case ARGT_RANGE:
		{
			//printf("%d is range\n",i);
			break;
		}
		case ARGT_FLOAT:
		{
			//printf("%d is float\n",i);
			break;
		}
		case ARGT_LIST:
		{
			//printf("%d is list\n",i);
			break;
		}
		case ARGT_FILE:
		{
			//printf("%d is file\n",i);

			break;
		}
		// we need one argument after flag
		case ARGT_VAL:
		{
			//printf("%d is !val\n",i);
			CHK_ARG(i,1);

			if (argl[pos].used == 1)
			{
				printf("Allready used %s\n", argv[i]);
				break;
			}

			arg_val *val = __create_arg( argl[pos].type, argl[pos].def );

			if (((s_arg_val*)argl[pos].def)->ptr != NULL)
				val->def = 0;
			val->used = 1;
			val->ptr = argv[i+1];

			__add_arg( ret, ARGT_VAL, val );
			//set that requied option allready where at cmd
			argl[pos].used = 1;

			//set used cmd arg
			used[i  ] = 1;
			used[i+1] = 1;

			i += 1;

			break;
		}
		// enouht that this is triggered
		case ARGT_FLAG:
		{
			arg_flag *flg = NULL;

			//printf("%d is flag\n", i);

			if ( argl[pos].used == 1 )
			{
				printf("Allready used %s\n", argv[i]);
				break;
			}

			flg = __create_arg( argl[pos].type, argl[pos].def );

			flg->used = 1;
			flg->flag = 1;

			__add_arg( ret, ARGT_FLAG, flg );


			argl[pos].used = 1;
			used[i] = 1;

			break;
		}
		default:
			printf("Unknown arg %d \"%s\"\n", i, argv[i]);

		}

		i++;
	}

	//printf("arg ");
	for (i=1;i<argc;i++)
	{
		if (used[i] == 0)
		{
			//printf("%d ",i);
		}
	}
	//printf("\n");

	free(used);


	return ret;
}


void arg_free( arg_t *arg )
{
	int i;

	for (i=0;i<arg->size;i++)
	{
		free( arg->arg[i]->val );
		free( arg->arg[i] );
	}
	free( arg->arg );

	free( arg );
}

int arg_type( arg_t *arg, int num )
{
	int ret = ARGT_NONE;



	return ret;
}


argv_t* arg_get( arg_t *arg, int num )
{
	argv_t *ret = NULL;



	return ret;
}


arg_ip*    arg_c_ip( uint32_t ip, uint16_t port )
{
	arg_ip *ret = NULL;

	ret = malloc( sizeof(arg_ip) );
	memset(ret,0,sizeof(arg_ip));

	ret->default_ip = ip;
	ret->default_port = port;

	return ret;
}


arg_range* arg_c_range( uint32_t start, uint32_t end, uint32_t step )
{
	arg_range* ret = NULL;

	ret = malloc( sizeof(arg_range) );
	memset( ret, 0, sizeof(arg_range) );

	ret->default_start = start;
	ret->default_end = end;
	ret->default_step = step;

	return ret;
}


arg_float* arg_c_float( float val )
{
	arg_float* ret = NULL;

	ret = malloc( sizeof(arg_float) );
	memset( ret, 0, sizeof(arg_float) );

	ret->default_val = val;

	return ret;
}


arg_list*  arg_c_list( uint32_t num, void **vals, void *def )
{
	arg_list *ret = NULL;

	ret = malloc( sizeof(arg_list) );
	memset( ret, 0, sizeof(arg_list) );

	ret->num = num;
	ret->vals = vals;
	ret->default_val = def;

	return ret;
}


arg_file*  arg_c_file( char *name )
{
	arg_file *ret = NULL;

	ret = malloc( sizeof(arg_file) );
	memset( ret, 0, sizeof(arg_file) );

	ret->default_name = name;

	return ret;
}


arg_val*   arg_c_val( char *ptr )
{
	arg_val *ret = NULL;

	ret = malloc( sizeof(arg_val) );
	memset( ret, 0, sizeof(arg_val) );

	ret->default_ptr = ptr;

	return ret;
}


arg_flag*  arg_c_flag()
{
	arg_flag *ret = NULL;

	ret = malloc( sizeof(arg_flag) );
	memset( ret, 0, sizeof(arg_flag) );

	ret->flag = 0;

	return ret;
}


void arg_print( arg_t *arg )
{
	int i = 0;
	argv_t *v = NULL;

	if ( arg == NULL )
	{
		printf("Nothing to print\n");
		return;
	}

	printf("| NUM |\n");
	for ( i=0; i<arg->size;i++ )
	{
		printf("|  %02d |\n", i);
		v = arg->arg[i];
		if (v == NULL)
			continue;
		printf("    ->| %02d | ", v->type);
		switch( v->type )
		{
		case ARGT_NONE:
		{
			printf("None\n");
			break;
		}
		case ARGT_IP:
		{
			printf("IP\n");
			break;
		}
		case ARGT_VAL:
		{
			arg_val *val = (void *)v->val;
			printf("Val | ");

			printf("%s\n",val->ptr);

			break;
		}
		case ARGT_FLAG:
		{
			arg_flag *flag = (void *)v->val;
			printf("FLg | ");

			printf("%d\n",flag->flag);

			break;
		}
		default:
			printf("Unknown\n");
		}

	}

}


int __search_arg( char *in, def_arg *arg)
{
	int ret = -1;
	int i = 0;

	i = 0;
	while ( arg[i].param != NULL )
	{
		if (strncmp(arg[i].param,in,strlen(in)) == 0)
			return i;
		i++;
	}


	return ret;
}


void* __create_arg( int type, void *val )
{
	void *ret = NULL;

	switch ( type )
	{
	case ARGT_NONE:
	{
		break;
	}

	case ARGT_IP:
	{
		arg_ip *ip = NULL;
		s_arg_ip *s_ip= val;

		ip = arg_c_ip( s_ip->ip, s_ip->port );

		ret = ip;
		break;
	}

	case ARGT_RANGE:
	{
		arg_range *range = NULL;
		s_arg_range *s_range = val;

		range = arg_c_range( s_range->start, s_range->end, s_range->end );

		ret = range;
		break;
	}

	case ARGT_FLOAT:
	{
		arg_float *fl = NULL;
		s_arg_float *s_fl = val;

		fl = arg_c_float( s_fl->val );

		ret = fl;
		break;
	}

	case ARGT_LIST:
	{
		arg_list *list = NULL;
		s_arg_list *s_list = NULL;

		list = arg_c_list( s_list->num, s_list->vals, s_list->default_val );

		ret = list;
		break;
	}

	case ARGT_FILE:
	{
		arg_file *f = NULL;
		s_arg_file *s_f = val;

		f = arg_c_file( s_f->name );

		ret = f;
		break;
	}

	case ARGT_VAL:
	{
		arg_val *v = NULL;
		s_arg_val *s_v = val;

		v = arg_c_val( s_v->ptr );

		ret = v;
		break;
	}
	case ARGT_FLAG:
	{
		arg_flag *flag = NULL;

		flag = arg_c_flag();

		ret = flag;
		break;
	}

	default:
		printf("Unknown type\n");
	}

	return ret;
}


int __add_arg( arg_t *arg, int type, void *val )
{
	int ret = 0;
	argv_t *argv = NULL;

	arg->arg = realloc( arg->arg, sizeof(void*)*(arg->size+1) );
	arg->size += 1;

	argv = malloc(sizeof(argv_t));
	memset(argv, 0, sizeof(argv_t));
	argv->type = type;
	argv->val = val;

	arg->arg[arg->size-1] = argv;

	return ret;
}