#define	_GNU_SOURCE

#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;
}

#ifndef	_GNU_SOURCE
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);
}
#endif

/* 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 && rule_id_type != type_string)
	{
		fprintf(stderr, "Rule-id of tree was not a symbol or string (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);
}

int	parse_hierarchy(char	**INPUT, int	*TYPE, void	**DATA)
{
	char	c, *p = *INPUT;
	struct lui_hierarchy	*h = NULL;
	*DATA = NULL;
	c = tokenize(&p);
	if(c!='[')
	{
		fprintf(stderr, "Expected '[' opening hierarchy structure\n");
		goto done;
	}
#define	EXPECT(cfieldtype, field, fieldtype, fieldname) \
		cfieldtype	field;	\
		int		field##_type; \
		parse_protocol(&p, &field##_type, (void**)&field); \
		if(field##_type != fieldtype) { \
			fprintf(stderr, fieldname " had wrong type (%d)\n", field##_type); goto done; }
	EXPECT(char*, name, type_string, "name of #H");
	EXPECT(lui_list*, parlist, type_list, "supertype-list of #H");
	EXPECT(lui_list*, sublist, type_list, "subtype-list of #H");
	do { c = tokenize(&p); } while(c==' ');
	if(c!=']')
	{
		fprintf(stderr, "Expected ']' ending hierarchy structure ; got '%c' = %d\n", c, c);
		goto done;
	}
	if(parlist->type==-1)parlist->type=type_int;
	if(sublist->type==-1)sublist->type=type_int;
	if(parlist->type != type_int || sublist->type != type_int)
		{ fprintf(stderr, "supertype and subtype lists for #H must be ints\n"); goto done; }
	h = calloc(sizeof(*h),1);
	h->name = name;
	h->npar = parlist->length;
	h->par = malloc(sizeof(int)*h->npar);
	int k;
	for(k=0;k<h->npar;k++)h->par[k] = *(int*)&parlist->data[k];
	h->nsub = sublist->length;
	h->sub = malloc(sizeof(int)*h->nsub);
	for(k=0;k<h->nsub;k++)h->sub[k] = *(int*)&sublist->data[k];
	done:;
	*TYPE = type_hierarchy;
	*INPUT=p;
	if(!h)
	{
		h = calloc(sizeof(*h), 1);
		h->name = strdup("*ERROR*");
	}
	*(struct lui_hierarchy**)DATA = h;
	return 0;
}

void	free_hierarchy(struct lui_hierarchy	*h)
{
	if(h->par)free(h->par);
	if(h->sub)free(h->sub);
	free(h->name);
	free(h);
}