#include "arg.h"

#include "debug.h"

//extern "C" void* emulate_cc_new(unsigned len) { \
//  void *p = malloc(len);
//  if (p == 0) {
//    /* Don't use stdio (e.g. fputs), because that may want to allocate more
//     * memory.
//     */
//    (void)!write(2, "out of memory\n", 14);
//    abort();
//  }
//  return p;
//}
//extern "C" void emulate_cc_delete(void* p) {
//  if (p != 0)
//    free(p);
//}
//void* operator new  (unsigned len) __attribute__((alias("emulate_cc_new")));
//void* operator new[](unsigned len) __attribute__((alias("emulate_cc_new")));   
//void  operator delete  (void* p)   __attribute__((alias("emulate_cc_delete")));
//void  operator delete[](void* p)   __attribute__((alias("emulate_cc_delete")));
//void* __cxa_pure_virtual = 0;


//for local usage only?
//int   __search_arg( char *in, def_arg *arg );
/*from s_arg_[TYPE] create type arg_[TYPE]*/
//void* __create_arg( int type, void *val );
/*add to argument list new parsed/recognized argument*/
//int   __add_arg( arg_t *arg, int type, void *val );

/*
/*
check if command line argument ARG[NUM<argc]
*/
//#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//

//	//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 );//

//	/***************************************************************************
//	Go troght all define arguments and try to parse and match all found arguments.
//	Prepare list of all recognized arguments
//	***************************************************************************/
//	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);
//			/*
//			CHK_ARG(i,1);//

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

//			arg_range *range = __create_arg(argl[pos].type, argl[pos].def);//
//
//

//			i += 1;//

//			*///

//			break;
//		}
//		case ARGT_FLOAT:
//		{
//			//printf("%d is float\n",i);
//			break;
//		}
//		case ARGT_LIST:
//		{
//			int j=0;
//			char **parse_params = NULL;
//			int param_num = 0;
//			s_arg_list *declared_params = argl[pos].def;
//			char *iter=NULL, *st=NULL, *s=NULL;//

//			//printf("%d is list\n",i);
//			CHK_ARG(i,1);//
//

//			if (argl[pos].used == 1)
//			{
//				printf("Allready used %s\n", argv[i]);
//				break;
//			}
//			
//			//super algo for parsing
//			iter = argv[i+1];
//			st = iter;
//			while ((*iter)!='\0')
//			{
//				if ((*iter)=='|')
//				{
//					if ((iter)>st)
//					{
//						s = malloc(iter-st+1);
//						memcpy(s, st, iter-st);
//						s[iter-st]=0;//

//						//TODO double flags will be passed in =P
//						for (j=0;j<declared_params->num;j++)
//						{
//							int n1 = strlen(s);
//							int n2 = strlen(declared_params->vals[j]);
//							int n = n1 > n2 ? n1 : n2;
//							if (strncmp(s,declared_params->vals[j],n)==0)
//							{
//								//PNL();
//								param_num += 1;
//								char **realoc_ptr = realloc(parse_params, sizeof(char *)*param_num);
//								if (realoc_ptr) 
//								{
//									parse_params = (char **)realoc_ptr;
//									parse_params[param_num-1] = s;
//								} else
//								{
//									param_num -= 1;
//								}
//							}
//						}
//						st = iter+1;
//					} else
//					{
//						st = iter+1;
//					}
//				}
//				iter++;
//				if (*iter=='\0')
//				{
//					if ((iter)>st)
//					{
//						s = malloc(iter-st+1);
//						memcpy(s, st, iter-st);
//						s[iter-st]=0;
//						
//						//some hash table could be nice to use here =p
//						//TODO double flags will be passed in =P
//						for (j=0;j<declared_params->num;j++)
//						{
//							int n1 = strlen(s);
//							int n2 = strlen(declared_params->vals[j]);
//							int n = n1 > n2 ? n1 : n2;
//							if (strncmp(s,declared_params->vals[j],n)==0)
//							{
//								param_num += 1;
//								char **realoc_ptr = realloc(parse_params, sizeof(char *)*param_num);
//								if (realoc_ptr) 
//								{
//									parse_params = (char **)realoc_ptr;
//									parse_params[param_num-1] = s;
//								} else
//								{
//									param_num -= 1;
//								}
//							}
//						}//

//						st = iter+1;
//					}
//				}
//			}//

//			arg_list *list=NULL;
//			{
//				//PNL();
//				//hack depends on __create_arg logic
//				s_arg_list arg;
//				arg.num = param_num;
//				arg.vals = parse_params;
//				list = __create_arg(argl[pos].type, &arg);
//			}//

//			//check param values//

//			if (-1 == __add_arg(ret, ARGT_LIST, list))
//			{
//				ENL();
//			}
//			//
//

//			argl[pos].used = 1;
//			((s_arg_list *)argl[pos].def)->result = list;//

//			used[i]   = 1;
//			used[i+1] = 1;//

//			i+=1;
//			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->ptr = argv[i+1];//

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

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

//			i += 1;//

//			break;
//		}
//		// enought 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->flag = 1;//

//			__add_arg( ret, ARGT_FLAG, flg );//
//
//

//			argl[pos].used = 1;
//			((s_arg_flag *)argl[pos].def)->result = flg;
//			
//			printf("result = ?\n");//

//			used[i] = 1;//

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

//		}//

//		i++;
//	}//

//	/*if some arguments wherent used then add default value*/
//	i = 0;
//	while(argl[i].param != NULL)
//	{
//		if (argl[i].used == 0)
//		{
//		switch(argl[i].type)
//		{
//		case ARGT_IP:
//		{
//			//printf("Not yet\n");
//			break;
//		}
//		case ARGT_RANGE:
//		{
//			//printf("Not yet\n");
//			break;
//		}
//		case ARGT_FLOAT:
//		{
//			//printf("Not yet\n");
//			break;
//		}
//		case ARGT_LIST:
//		{
//			//printf("Not yet\n");
//			break;
//		}
//		case ARGT_FILE:
//		{
//			//printf("Not yet\n");
//			break;
//		}
//		case ARGT_VAL:
//		{
//			printf("VAL default\n");
//			arg_val *val= __create_arg( argl[i].type, argl[i].def );
//			val->ptr = ((s_arg_val *)argl[i].def)->default_ptr;
//			((s_arg_val *)argl[i].def)->result = val;
//			break;
//		}
//		case ARGT_FLAG:
//		{
//			printf("FLAG default\n");
//			arg_flag *flag= __create_arg( argl[i].type, argl[i].def );
//			//flag->flag = ((s_arg_flag *)argl[i].def)->flag;
//			flag->flag = 0;
//			((s_arg_flag *)argl[i].def)->result = flag;
//			break;
//		}
//		default:
//		{
//			printf("Unknown type\n");
//		}
//		}
//		}//

//		i++;
//	}//

//	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->ip = ip;
	ret->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->start = start;
	ret->end = end;
	ret->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->val = val;

	return ret;
}


arg_list* arg_c_list( uint32_t num, char **vals)
{
	int i;
	arg_list *ret = NULL;
	char **ptr_c=NULL;

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

	ptr_c = malloc(sizeof(char*)*num);
	for (i=0;i<num;i++)
	{
		ptr_c[i] = vals[i];
	}

	ret->num = num;
	ret->vals = ptr_c;

	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->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->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_LIST:
		{
			int k;
			arg_list *lst = (arg_list *)v->val;
			printf("Lst | ");
			for (k=0;k<lst->num;k++)
			{
				printf("%s ", lst->vals[k]);
			}
			printf("\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 = val;

		//so NULL where given as we use *->* then be carefull
		if (s_list != NULL)
		{
			list = arg_c_list( s_list->num, s_list->vals );
		}

		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 )
{
	argv_t *argv = NULL;

	void *new_ptr = NULL;

	new_ptr =  realloc( arg->arg, sizeof(void*)*(arg->size+1) );
	if (new_ptr == NULL)
	{
		ENL();
		return -1;
	}
	arg->arg = new_ptr;
	arg->size += 1;

	argv = malloc(sizeof(argv_t));
	if (argv == NULL)
	{
		//do resize back reallocated arg->arg
		ENL();
		return -1;
	}
	memset(argv, 0, sizeof(argv_t));
	argv->type = type;
	argv->val = val;

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

	return 0;
}
*/




/*
CmdArgVar::CmdArgVar()
{
	this->_type = 0;
	this->val = NULL;
}

uint8_t* CmdArgVar::get()
{
	return this->val;
}

int CmdArgVar::type()
{
	return this->_type;
}
*/
/*
CmdArg::CmdArg()
{
	this->used = 0;
	this->_size = 0;
	this->arg = NULL;
}

int CmdArg::isUsed()
{
	return this->used;
}

int CmdArg::size()
{
	return this->_size;
}
*/

CmdArgFloat::CmdArgFloat()
{
	this->used = 0;
	this->val = 0.0f;
}

int CmdArgFloat::isUsed()
{
	return this->used;
}

float CmdArgFloat::get()
{
	return this->val;
}

CmdArgFloatConf::CmdArgFloatConf()
{
	this->used = 0;
	this->def = 0;
	this->val = 0.0f;
	this->default_val = 0.0f;
	this->result = NULL;
}

void CmdArgFloatConf::link(CmdArgFloat *floatArg)
{
	this->result = floatArg;
}

int CmdArgFloatConf::isUsed()
{
	return this->used;
}

CmdArgFlag::CmdArgFlag()
{
	this->used = 0;
	this->flag = 0;
}

int CmdArgFlag::isUsed()
{
	return this->used;
}

int CmdArgFlag::get()
{
	return this->flag;
}

void CmdArgFlag::setUsed() {
	this->used = 1;
}

int CmdArgFlag::getValue() {
	return this->flag;
}

void CmdArgFlag::setFlag() {
	this->flag = 1;
}

CmdArgFlagConf::CmdArgFlagConf()
{
	this->used = 0;
	this->flag = 0;
	this->result = NULL;
}

CmdArgFlagConf::CmdArgFlagConf(int flag)
{
	this->used = 0;
	this->flag = flag;
	this->result = NULL;
}

int CmdArgFlagConf::isUsed()
{
	return this->used;
}

void CmdArgFlagConf::setUsed() {
	this->used=1;
}

void CmdArgFlagConf::link(CmdArgFlag *flagArg)
{
	this->result = flagArg;
}

CmdArgDefault::CmdArgDefault()
{
	this->param = NULL;
	this->type = 0;
	this->def = NULL;
	this->used = 0;
	this->help = NULL;
	this->result = NULL;
}

/*
CmdArgDefault::CmdArgDefault(char *param, uint32_t type, void *def, char *help, void *result)
{
	this->param = param;
	this->type = type;
	this->def = def;
	this->used = 0;
	this->help = help;
	this->result = result;
}
*/

CmdArgDefault::CmdArgDefault(char *param, CmdArgFlagConf *def, char *help, CmdArgFlag *result)
{
	//printf("Construct CmdArgDefault::CmdArgDefault(char *param, CmdArgFlagConf *def, char *help, CmdArgFlag *result)\n");
	this->param = param;
	this->type = ARGT_FLAG;
	this->def = (void *)def;
	this->used = 0;
	this->help = help;
	this->result = (void *)result;
}


void CmdArgDefault::setParam(char *param)
{
	this->param = param;
}

char* CmdArgDefault::getParam() {
	return this->param;
}

void CmdArgDefault::setType(uint32_t type)
{
	this->type = type;
}

uint32_t CmdArgDefault::getType()
{
	return this->type;
}

void CmdArgDefault::setDefValue(void *def)
{
	this->def = def;
}

int  CmdArgDefault::isUsed()
{
	return this->used;
}

void CmdArgDefault::setUsed() {
	this->used = 1;
}

void CmdArgDefault::setHelp(char *help)
{
	this->help = help;
}


void CmdArgDefault::link(void *result)
{
	this->result = result;
}

void *CmdArgDefault::getResult() {
	return this->result;
}

void *CmdArgDefault::getDefault() {
	return this->def;
}


CmdArg::CmdArg()
{
	this->num = 0;
	this->defaultArgs = NULL;
}

void CmdArg::load(int argc, char **argv)
{
	int i;
	int pos;

	i = 1;
	while (i < argc) {

		pos = this->searchArg(argv[i]);

		if (pos==-1) {
			printf("Couldnt find any arguments\n");
			break;
		}
		CmdArgDefault *param = (CmdArgDefault *)this->defaultArgs[pos];
		switch (param->getType()) {
			case ARGT_IP: {
				break;
			}

			case ARGT_RANGE: {
				break;
			}

			case ARGT_FLOAT: {
				break;
			}

			case ARGT_LIST: {
				break;
			}

			case ARGT_FILE: {
				break;
			}

			case ARGT_VAL: {
				break;
			}

			case ARGT_FLAG: {
				
				CmdArgFlag *flag=(CmdArgFlag *)param->getResult();
				CmdArgFlagConf *conf=(CmdArgFlagConf *)param->getDefault();

				param->setUsed();
				flag->setUsed();
				flag->setFlag();
				conf->setUsed();

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

		i++;
	}
}

void CmdArg::add(CmdArgDefault *param)
{
	if (param == NULL) {
		return;
	} 

	this->num += 1;
	void *new_ptr=NULL;
	new_ptr = realloc(this->defaultArgs, sizeof(void *)*this->num);
	if (new_ptr != NULL)
	{
		this->defaultArgs = (void **)new_ptr;
		new_ptr = NULL;
	} else {
		this->num-=1;
		printf("Couldnt allocate memory\n");
		return;
	}
	CmdArgDefault *p = (CmdArgDefault *)param;
	printf("Added type %d\n", p->getType());

	this->defaultArgs[this->num-1] = param;
}

int CmdArg::searchArg(char *in) {
	int i;
	for (i=0;i<this->num;i++) {
		CmdArgDefault *param = (CmdArgDefault *)this->defaultArgs[i];
		if (strncmp(param->getParam(), in, strlen(in)) == 0) {
			return i;
		}
	}
	return -1;
}