#include "rpn_ifs.h"

rpn_ifs_t* rpn_ifs_new(rpn_if_param_t *params, rpn_value_t *memmap)
{
	rpn_ifs_t *res;
	int err;

	if(!(res = malloc(sizeof(rpn_ifs_t))))
	{
		goto error;
	}
	bzero(res, sizeof(rpn_ifs_t));

	memcpy(&(res->params), params, sizeof(rpn_if_param_t));

	if(memmap)
	{
		res->self_mem = 0;
		res->mem = memmap;
	}
	else
	{
		res->self_mem = 1;
		res->mem = mmap(NULL, params->mem_sz, PROT_READ|PROT_WRITE, MAP_ANON,
			-1, 0);
		if(res->mem == (void*)-1)
		{
			goto mmap_err;
		}
	}

	return res;

	mmap_err:
		err = errno;
		free(res);
	error:
		err = errno;
		errno = err;
		return NULL;
}

void rpn_ifs_free(rpn_ifs_t *rifs)
{
	while(rifs->if_sz)
	{
		rpn_if_free(rifs->rpn_if[--(rifs->if_sz)]);
	}
	if(rifs->self_mem)
	{
		munmap(rifs->mem, rifs->params.mem_sz);
	}
	if(rifs->rpn_if)
	{
		free(rifs->rpn_if);
	}
	if(rifs->weight)
	{
		free(rifs->weight);
	}
}

size_t rpn_ifs_add_if(rpn_ifs_t *rifs, unsigned int weight)
{
	size_t res, i, first_flat;
	void *tmp;

	res = rifs->if_sz + 1;

	if(!(tmp = realloc(rifs->rpn_if, sizeof(rpn_if_t*) * res)))
	{
		return 0;
	}
	rifs->rpn_if = tmp;

	if(!(tmp = realloc(rifs->weight, sizeof(unsigned int) * res)))
	{
		return 0;
	}
	rifs->weight = tmp;

	rifs->weight[rifs->if_sz] = weight;
	//WRONG expr ARGUMENT !!!
	rifs->rpn_if[rifs->if_sz] = rpn_if_new(&(rifs->params), rifs->mem);
	if(!rifs->rpn_if[rifs->if_sz])
	{
		return 0;
	}
	
	first_flat = rifs->params.rpn_sz;
	rifs->flat_sz += rifs->params.rpn_sz;
	if(!(tmp = realloc(rifs->flat_rpn, sizeof(rpn_expr_t*) * rifs->flat_sz)))
	{
		return 0;
	}
	for(i=0; i<rifs->params.rpn_sz;i++)
	{
		rifs->flat_rpn[first_flat + i] = &(rifs->rpn_if[rifs->if_sz]->rpn[i]);
	}

	rifs->if_sz++;
	if(rpn_ifs_weight_update(rifs) < 0)
	{
		rpn_ifs_del_if(rifs, res); // don't attempt to ceck for errors..
		return 0;
	}
	return res;
}

int rpn_ifs_del_if(rpn_ifs_t *rifs, size_t if_idx)
{
	size_t sz_mv;
#ifdef DEBUG
	if(if_idx >= rifs->if_sz)
	{
		dprintf(2, "Error, wrong IF index given when attempt to delete from IFS");
		errno = EINVAL;
		return -1;
	}
#endif

	rpn_if_free(rifs->rpn_if[rifs->if_sz - 1]);
	if(if_idx < rifs->if_sz - 1)
	{
		sz_mv = rifs->if_sz - if_idx;
		memmove(rifs->rpn_if + if_idx, rifs->rpn_if + if_idx + 1, sz_mv);
		memmove(rifs->weight + if_idx, rifs->weight + if_idx + 1, sz_mv);
	}

	rifs->if_sz--;
	rifs->flat_sz -= rifs->params.rpn_sz;
	return 0;
}

int rpn_ifs_run(rpn_ifs_t *rifs, size_t n)
{
	return 0;
}

int rpn_ifs_weight_update(rpn_ifs_t *rifs)
{
	unsigned long int weight_sum;
	size_t i, j, max;
	rpn_if_t **proba;

	proba = rifs->if_proba;
	bzero(rifs->if_proba, sizeof(rpn_if_t*)*255);

	weight_sum = 0;

	for(i=0; i < rifs->if_sz; i++)
	{
		weight_sum += rifs->weight[i];
	}
	j=0;
	for(i=0; i < rifs->if_sz; i++)
	{
		max = rifs->weight[i] * 255 / weight_sum;
		while(max)
		{
			*proba = rifs->rpn_if[i];
			max--;
			j++;
		}
	}
	return 0;
}

rpn_expr_t **rpn_ifs_flat_rpn(rpn_ifs_t *rifs)
{
	return NULL;
}

int rpn_ifs_step(rpn_ifs_t *rifs)
{
	return 1;
}