#include	<string.h>
#include	<stdio.h>
#include	<stdlib.h>
#include	"lkb-tree.h"
#include	"lkb-protocol.h"

static void adjoin_subtree(lkb_tree	*tr, lkb_tree	*sub);
static void	r_copy_lkb_tree(lkb_tree	*t, lkb_tree	*to);

static void		r_free_lkb_tree(lkb_tree	*t)
{
	int	i;

	for(i=0;i<t->ndaughters;i++)
		r_free_lkb_tree(t->daughters+i);
	free(t->daughters);
	free(t->root_name);
}

void	free_lkb_tree(lkb_tree	*t)
{
	(*t->refcnt)--;
	if((*t->refcnt)<=0)
	{
		free(t->refcnt);
		free(t);
	}
}

static void r_copy_lkb_tree(lkb_tree	*t, lkb_tree	*to)
{
	int	i;
	*to = *t;
	to->root_name = strdup(to->root_name);
	if(to->sublabel_id)to->sublabel_id = strdup(to->sublabel_id);
	if(to->rule_id)to->rule_id = strdup(to->rule_id);
	to->daughters = malloc(sizeof(*t)*to->ndaughters);
	for(i=0;i<to->ndaughters;i++)
		r_copy_lkb_tree(t->daughters+i, to->daughters+i);
}

lkb_tree	*copy_lkb_tree(lkb_tree	*t)
{
	lkb_tree	*to = malloc(sizeof(*t));

	r_copy_lkb_tree(t, to);
	to->refcnt = t->refcnt;
	(*t->refcnt)++;
	return to;
}

static int	strnlen(char	*str, int	len)
{
	int	i;

	for(i=0;i<len;i++)
		if(!str[i])return i;
	return len;
}

static char	*strndup(char	*str, int	len)
{
	char	*ret;
	int		l = strnlen(str, len);

	ret = malloc(l+1);
	return strncpy(ret, str, len);
}

/* tree protocol parser */

int			parse_tree(char	**INPUT, int	*TYPE, void	**DATA)
{
	int		id_type, type_type, subtree_type, edge_id_type, rule_id_type, sublabel_id_type;
	char	*tree_type_d, *rule_id_d, *sublabel_id_d;
	int		tree_id_d, edge_id_d;
	lkb_tree	*subtree;
	char	*p = *INPUT;
	char	c;
	lkb_tree	*tr=0;

	*DATA = 0;
	//debug("parsing tree at %s\n", *INPUT);
	c = tokenize(&p);
	if(c!='[')
	{
		fprintf(stderr, "Expected '[' opening tree structure\n");
		goto done_tree;
	}
	parse_protocol(&p, &id_type, (void**)&tree_id_d);
	if(id_type != type_int)
	{
		fprintf(stderr, "ID of tree was not a number (type %d)\n", id_type);
		goto done_tree;
	}
	parse_protocol(&p, &type_type, (void**)&tree_type_d);
	if(type_type != type_symbol && type_type != type_string)
	{
		fprintf(stderr, "Type of tree was not a symbol or a string (type %d)\n", type_type);
		goto done_tree;
	}
	parse_protocol(&p, &sublabel_id_type, (void**)&sublabel_id_d);
	if((sublabel_id_type != type_symbol || strcmp(sublabel_id_d, "NIL")) && sublabel_id_type != type_string)
	{
		fprintf(stderr, "Sublabel-id of tree was not valid (type %d)\n", sublabel_id_type);
		goto done_tree;
	}
	if(sublabel_id_type == type_symbol)
	{
		free(sublabel_id_d);
		sublabel_id_d = 0;
	}
	parse_protocol(&p, &edge_id_type, (void**)&edge_id_d);
	if(edge_id_type != type_int)
	{
		fprintf(stderr, "Edge-id of tree was not an int (type %d)\n", edge_id_type);
		goto done_tree;
	}
	parse_protocol(&p, &rule_id_type, (void**)&rule_id_d);
	if(rule_id_type != type_symbol)
	{
		fprintf(stderr, "Rule-id of tree was not a symbol (type %d)\n", rule_id_type);
		goto done_tree;
	}

	tr = (lkb_tree*)calloc(sizeof(lkb_tree), 1);
	tr->id = tree_id_d;
	tr->edge_id = edge_id_d;
	tr->rule_id = rule_id_d;
	tr->root_name = tree_type_d;
	tr->sublabel_id = sublabel_id_d;
	tr->ndaughters = 0;
	tr->refcnt = malloc(sizeof(int));
	*(tr->refcnt) = 1;
	//debug("tree id %d, type %s\n", tr->id, tr->root_name);

	do
	{
		c = tokenize(&p);
		if(c==' ')continue;
		if(c==']')break;
		p--;
		parse_protocol(&p, &subtree_type, (void**)&subtree);
		if(subtree_type != type_tree)
		{
			fprintf(stderr, "Subtree was not a tree (type %d)\n", subtree_type);
			goto done_tree;
		}
		adjoin_subtree(tr, subtree);
	} while(*p);
	//debug("tree finished\n");

	done_tree:
	*TYPE = type_tree;
	*INPUT=p;
	if(!tr)
	{
		tr = (lkb_tree*)calloc(sizeof(lkb_tree), 1);
		tr->id = -1;
		tr->edge_id = -1;
		tr->rule_id = strdup("error-rule");
		tr->root_name = strdup("*ERROR*");
		tr->sublabel_id = 0;
		tr->ndaughters = 0;
		tr->refcnt = malloc(sizeof(int));
		*(tr->refcnt) = 1;
	}
	*(lkb_tree**)DATA = tr;
	return 0;
}

static void adjoin_subtree(lkb_tree	*tr, lkb_tree	*sub)
{
	tr->ndaughters++;
	tr->daughters = realloc(tr->daughters, sizeof(lkb_tree)*tr->ndaughters);
	tr->daughters[tr->ndaughters-1] = *sub;
	free(sub);
}