#include	<unistd.h>
#include	<sys/fcntl.h>
#include	<stdio.h>
#include	<stdlib.h>
#include	<string.h>
#include	<assert.h>

#include	<yz/window.h>
#include	<yz/draw.h>
#include	<yzuitk/menu.h>
#include	<yzuitk/scrollbar.h>
#include	"embedded-view.h"
#include	"font-info.h"
#include	"lui-treebank.h"
#include	"lkb-avm.h"
#include	"lkb-protocol.h"

lui_treebank_session	*current_session = NULL;

lui_treebank_session	*find_treebank_session(int	sid)
{
	if(current_session && current_session->id == sid)
		return current_session;
	return NULL;
}

register_treebank_session(lui_treebank_session	*sess)
{
	current_session = sess;
}

char	*get_avm_feature(lkb_avm	*a, char	*feat);
char	*my_avm_tag_type(lkb_avm	*avm, lkb_avm_tag	*tag)
{
	int	i;
	for(i=0;i<avm->nattr;i++)
	{
		if(avm->attr_what[i] == avm_tag)continue;
		if(avm->attr_tag[i] && !strcmp(tag->name, avm->attr_tag[i]->name))
		{
			// found it
			return get_avm_feature(avm, avm->attr_name[i]);
		}
		if(avm->attr_what[i] == avm_structure)
		{
			char	*res = my_avm_tag_type(avm->attr_value[i], tag);
			if(res)return res;
		}
		if(avm->attr_what[i] == avm_list)
		{
			// just assume it's not defined inside a list for tokens, ok?
			//char	*res = avm_tag_type_list(avm->attr_value[i], tag);
			//if(res)return res;
		}
	}
	return NULL;
}

char	*get_avm_feature(lkb_avm	*a, char	*feat)
{
	int	i, type;
	lkb_avm_tag	*tag = NULL;
	lkb_avm	*v = find_attribute(a, feat, &type, &tag);
	if(!v && !tag)return NULL;
	switch(type)
	{
		case	avm_terminal:	return (char*)v;
		case	avm_structure:	return v->type;
		case	avm_list:		return "list";
		case	avm_tag:		return my_avm_tag_type(a, tag);
	}
}

int	qatoi(char	*qa)
{
	if(!qa)return -1;
	if(qa[0]!='"')return atoi(qa);
	return atoi(qa+1);
}

load_tokens(lui_treebank_session	*sess, lui_list	*tokens)
{
	sess->ntokens = tokens->length;
	sess->tokens = calloc(sizeof(struct lui_token), tokens->length);
	assert(tokens->type == type_dag);
	int i;
	int	max_cto = 0;
	for(i=0;i<tokens->length;i++)
	{
		struct lui_token	*T = &sess->tokens[i];
		lkb_avm	*A = tokens->data[i];
		T->cfrom = qatoi(get_avm_feature(A, "+FROM"));
		T->cto = qatoi(get_avm_feature(A, "+TO"));
		T->string = get_avm_feature(A, "+FORM")?:"?";
		if(T->cto > max_cto)max_cto = T->cto;
		//printk("token %d : [%d-%d] %s\n", i, T->cfrom, T->cto, T->string);
	}

	sess->text = calloc(max_cto + 1, 1);
	for(i=0;i<max_cto;i++)sess->text[i] = ' ';
	for(i=0;i<sess->ntokens;i++)
	{
		struct lui_token	*T = &sess->tokens[i];
		//printf("string = '%s' ; %d - %d\n", T->string, T->cto, T->cfrom);
		assert(strlen(T->string) == T->cto-T->cfrom);
		memcpy(sess->text + T->cfrom, T->string, T->cto-T->cfrom);
	}
	//printk("text = '%s'\n", sess->text);
}

load_truths(lui_treebank_session	*sess, lui_list	*truths)
{
	sess->ntruths = truths->length;
	sess->truths = calloc(sizeof(struct lui_truth), truths->length);
	assert(truths->type == type_dag);
	int i;
	for(i=0;i<truths->length;i++)
	{
		struct lui_truth	*T = &sess->truths[i];
		lkb_avm				*A = truths->data[i];
		T->cfrom = qatoi(get_avm_feature(A, "+FROM"));
		T->cto = qatoi(get_avm_feature(A, "+TO"));
		T->sign = get_avm_feature(A, "SIGN")?:"?";
		T->label = get_avm_feature(A, "LABEL")?:"?";
		//browse_avm(1, A, strdup("truth"), NULL);
		printf("truth: [%d - %d] = %s = %s\n", T->cfrom, T->cto, T->sign, T->label);
	}
}

int	browse_treebank(int	session_id, int	remaining_count, lui_list	*tokens, lui_list	*truth, lui_list	*choices)
{
	lui_treebank_session	*session = find_treebank_session(session_id);
	if(!session)
	{
		session = calloc(sizeof(*session),1);
		session->id = session_id;
		session->remaining_count = remaining_count;
		load_tokens(session, tokens);
		load_truths(session, truth);
		session->choices = choices;
		register_treebank_session(session);
		new_treebank_session(session, strdup("Treebanking"));
		printk("start a new treebank session %d\n", session_id);
	}
	else
	{
		printk("update an existing treebank session %d\n", session_id);
		session->remaining_count = remaining_count;
		load_tokens(session, tokens);
		load_truths(session, truth);
		session->choices = choices;
	}
	printk("%d remaining trees\n", session->remaining_count);
	printk("%d tokens\n", session->ntokens);
	printk("%d truths\n", session->ntruths);
	printk("%d choices\n", session->choices->length);
}





/* treebank view */
struct treebank_priv
{
	char		*shown_bar;
	lui_treebank_session	*session;
	int	token_separator_line_y;
	int	text_width;
};

#define	TP	((struct treebank_priv*)view->private)

font_info	tokens_font = {"palatino", 16, fsRoman, {0,0,40000}, 0};
font_info	truths_font = {"palatino", 16, fsRoman, {40000,0,0}, 0};
font_info	treebank_bar_font = {"helvetica", 12, fsRoman, {0,0,0}, 0};

int	init_treebank_view(embedded_view_t	*view, int	id, lui_treebank_session	*session)
{
	view->private = malloc(sizeof(struct treebank_priv));
	TP->session = session;
	TP->shown_bar = NULL;

	use_font(&tokens_font);
	TP->text_width = yzStringSize(TP->session->text, strlen(TP->session->text));

	int	height_need = TP->text_width + 80;
	view->width = TP->text_width + 50;
	view->height = height_need;
	TP->token_separator_line_y = height_need - 80;
	/*calculate_tree_placement(TP->tree, &big_params);
	offset_tree_position(TP->tree, TP->tree->left, 0);
	view->width = (TP->tree->left+TP->tree->right) + 30;
	view->height = TP->tree->height + 15;*/
	return 0;
}

void	close_treebank_view(embedded_view_t	*view)
{
	printk("closing treebank session %d\n", TP->session->id);
	free(TP);
}

void	layout_treebank(lui_treebank_session	*S)
{
}

void	update_treebank_view(embedded_view_t	*view, int	x1, int	y1, int	x2, int	y2)
{
	yzPenColor(65535,65535,65535);
	yzRect(x1, y1, x2, y2);
	yzPenColor(0,0,0);

	struct lui_treebank_session	*S = TP->session;
	yzLine(0, TP->token_separator_line_y, view->width, TP->token_separator_line_y);
	int	i, x, y = TP->token_separator_line_y + 25;
	use_font(&tokens_font);
	for(i=0;i<S->ntokens;i++)
	{
		char	*text = S->tokens[i].string;
		x = 25 + yzStringSize(S->text, S->tokens[i].cfrom);
		yzText(x, y, text);
	}

	for(i=0;i<S->ntruths;i++)
	{
		struct lui_truth	*T = &S->truths[i];
		char	*text = T->label;
		int	xl = 25 + yzStringSize(S->text, T->cfrom);
		int	xr = 25 + yzStringSize(S->text, T->cto);
		int	xc = (xl + xr) / 2;
		y = TP->token_separator_line_y - yzStringSize(S->text+T->cfrom, T->cto-T->cfrom)/2;
		x  = xc - yzStringSize(text, strlen(text))/2;
		use_font(&truths_font);
		yzText(x, y, text);
		yzPenColor(0,0,0);
		yzLine(xc, y+3, xl, TP->token_separator_line_y);
		yzLine(xc, y+3, xr, TP->token_separator_line_y);
	}

	if(x2-x1+1 == view->vis_width && y2-y1+1 == view->vis_height)
		show_bar(view, TP->shown_bar, 1, 1, &treebank_bar_font);
}

void	event_treebank_view(embedded_view_t	*view, event_t	ev)
{
	printk("got an event\n");
}

void	treebank_mouse(embedded_view_t	*view, int	x, int	y)
{
}

void	postscript_treebank_view(embedded_view_t	*view)
{
}

void	latex_treebank_view(embedded_view_t	*view)
{
}

embedded_view_t	prototype_treebank_view = {
			init:	(int(*)(embedded_view_t*,...))init_treebank_view,
			update:	update_treebank_view,
			event:	event_treebank_view,
			postscript: postscript_treebank_view,
			latex: latex_treebank_view,
			close:	close_treebank_view,
			mouse_moved: treebank_mouse};