#ifndef PRINT_C
#define PRINT_C PRINT_C
#include<print.h>

void print_keyword_enum(enum Keyword code)
{
	switch(code)
	{
		case KW_MACHINE:
			printf("KW_MACHINE");
			break;
		case KW_FROM:
			printf("KW_FROM");
			break;
		case KW_TO:
			printf("KW_TO");
			break;
		case KW_ON:
			printf("KW_ON");
			break;
		case KW_ID:
			printf("KW_ID");
			break;
		case KW_STRING:
			printf("KW_STRING");
			break;
		case KW_NOP:
			printf("KW_NOP");
			break;
		case KW_EOF:
			printf("KW_EOF");
			break;
		case KW_OPEN_SQUARE:
			printf("KW_OPEN_SQUARE");
			break;
		case KW_CLOSE_SQUARE:
			printf("KW_CLOSE_SQUARE");
			break;
		case KW_OPEN_NORMAL:
			printf("KW_OPEN_NORMAL");
			break;
		case KW_CLOSE_NORMAL:
			printf("KW_CLOSE_NORMAL");
			break;
		case KW_PIPE:
			printf("KW_PIPE");
			break;
		case KW_SEMI_COLUMN:
			printf("KW_SEMI_COLUMN");
			break;
		case KW_STARTING:
			printf("KW_STARTING");
			break;
		case KW_STATES:
			printf("KW_STATES");
			break;
		case KW_EVENTS:
			printf("KW_EVENTS");
			break;
		case KW_EVENT:
			printf("KW_EVENT");
			break;
		case KW_EXECUTE:
			printf("KW_EXECUTE");
			break;
		case KW_TRANSITIONS:
			printf("KW_TRANSITIONS");
			break;
		case KW_COMMA:
			printf("KW_COMMA");
			break;
		case KW_DOT:
			printf("KW_DOT");
			break;
		case KW_AND:
			printf("KW_AND");
			break;
		case KW_OR:
			printf("KW_OR");
			break;
		case KW_NOT:
			printf("KW_NOT");
			break;
		case KW_IF:
			printf("KW_IF");
			break;
		case KW_ELSE:
			printf("KW_ELSE");
			break;
		case KW_GRANTED:
			printf("KW_GRANTED");
			break;
		case KW_ENTERING:
			printf("KW_ENTERING");
			break;
		case KW_EXITING:
			printf("KW_EXITING");
			break;
		default:
			printf("LEXERROR");
	}
}
void print_token(struct token *token)
{
	size_t i;
	assert(token);

	printf("[ ");
	print_keyword_enum(token->type);
	printf(" ");
	for(i=0;i<token->size;++i)
		printf("%c",token->data[i]);
	printf(" ] ");

}
void print_tokens(struct Queue *tokens)
{
	struct Queue_Node *it;
	assert(tokens);

	for(it=tokens->first;it!=NULL;it=it->prev)
	{
		print_token( (struct token*)(it->data));
		printf(" ");
	}
}
void print_ast_enum(enum AST_Type type)
{
	switch(type)
	{
		case AST_TYPE_TRANSLATION_UNIT:
			printf("AST_TYPE_TRANSLATION_UNIT");
			break;
		case AST_TYPE_MACHINE:
			printf("AST_TYPE_MACHINE");
			break;
		case AST_TYPE_STATE:
			printf("AST_TYPE_STATE");
			break;
		case AST_TYPE_STATES:
			printf("AST_TYPE_STATES");
			break;
		case AST_TYPE_EVENT:
			printf("AST_TYPE_EVENT");
			break;
		case AST_TYPE_EVENTS:
			printf("AST_TYPE_EVENTS");
			break;
		case AST_TYPE_TRANSITION:
			printf("AST_TYPE_TRANSITION");
			break;
		case AST_TYPE_TRANSITIONS:
			printf("AST_TYPE_TRANSITIONS");
			break;
		case AST_TYPE_COMMAND:
			printf("AST_TYPE_COMMAND");
			break;
		case AST_TYPE_PIPELINE:
			printf("AST_TYPE_PIPELINE");
			break;
		case AST_TYPE_OP_AND:
			printf("AST_TYPE_OP_AND");
			break;
		case AST_TYPE_OP_OR:
			printf("AST_TYPE_OP_OR");
			break;
		case AST_TYPE_OP_NOT:
			printf("AST_TYPE_OP_NOT");
			break;
		case AST_TYPE_OP_SELECTOR:
			printf("AST_TYPE_OP_SELECTOR");
			break;
		case AST_TYPE_UNFINISHED_STATE:
			printf("AST_TYPE_UNFINISHED_STATE");
			break;
		case AST_TYPE_IF:
			printf("AST_TYPE_IF");
			break;
		default:
			printf("AST_NOP");
	}

}
void print_ast(struct AST *tree)
{
	assert(tree);

	switch(tree->type)
	{
		case AST_TYPE_MACHINE:
			print_ast_machine((struct AST_Machine*)tree);
			break;
		case AST_TYPE_STATE:
			print_ast_state((struct AST_State*)tree);
			break;
		case AST_TYPE_STATES:
			print_ast_states((struct AST_States*)tree);
			break;
		case AST_TYPE_EVENT:
			print_ast_event((struct AST_Event*)tree);
			break;
		case AST_TYPE_EVENTS:
			print_ast_events((struct AST_Events*)tree);
			break;
		case AST_TYPE_TRANSITION:
			print_ast_transition((struct AST_Transition*)tree);
			break;
		case AST_TYPE_TRANSITIONS:
			print_ast_transitions((struct AST_Transitions*)tree);
			break;
		case AST_TYPE_COMMAND:
			print_ast_command((struct AST_Command*)tree);
			break;
		case AST_TYPE_PIPELINE:
			print_ast_pipeline((struct AST_Pipeline*)tree);
			break;
		case AST_TYPE_TRANSLATION_UNIT:
			print_ast_translation_unit((struct AST_Translation_Unit*)tree);
			break;
		case AST_TYPE_OP_AND:
		case AST_TYPE_OP_OR:
		case AST_TYPE_OP_SELECTOR:
			print_ast_binary_expression((struct AST_Binary_Expression*)tree);
			break;
		case AST_TYPE_OP_NOT:
			print_ast_unary_expression((struct AST_Unary_Expression*)tree);
			break;
		case AST_TYPE_UNFINISHED_STATE:
			print_ast_unchecked_state((struct AST_Unchecked_State*)tree);
			break;
		case AST_TYPE_IF:
			print_ast_if_statement((struct AST_If_Statement*)tree);
			break;
		default:
			printf("noast");
	}
}
void print_ast_state(struct AST_State* tree)
{
	assert(tree);

	printf("[ STATE: ");
	print_token(tree->name);
	printf(" %ld",tree->number);
	printf("]");
}
void print_ast_event(struct AST_Event* tree)
{
	assert(tree);

	printf("[ EVENT: ");
	print_token(tree->name);
	printf("]");
}
void print_ast_states(struct AST_States* tree)
{
	size_t i;
	assert(tree);

	printf("STATES [\n");
	for(i=0;i<tree->number_of_states;++i)
	{
		print_ast_state(tree->states[i]);
		printf(" ");
	}
	printf("\n ] END STATES \n");
}
void print_ast_events(struct AST_Events* tree)
{
	size_t i;
	assert(tree);

	printf("EVENTS [\n");
	for(i=0;i<tree->number_of_events;++i)
	{
		print_ast_event(tree->events[i]);
		printf(" ");
	}
	printf("\n ] END EVENTS \n");
}
void print_ast_transition(struct AST_Transition* tree)
{
	assert(tree);

	printf("TRANSITION [\nFROM");
	print_ast_state(tree->from);
	printf(" TO ");
	print_ast_state(tree->to);
	printf(" COMMAND {");
	if(tree->statement==NULL)
	{
		printf("NULL");
	}else
	{
		print_ast(tree->statement);
	}

}
void print_ast_command(struct AST_Command* tree)
{
	assert(tree);

	printf("( command ");
	print_token(tree->function_name);
	if(tree->argument==NULL)
	{
		printf(" NOARGUMENTS ");
	}else
	{
		printf(" \"");
		print_token(tree->argument);
		printf("\" ");
	}
	printf(")");
}
void print_ast_pipeline(struct AST_Pipeline* tree)
{
	size_t i;
	assert(tree);
	printf("PIPELINE <");
	for(i=0;i<tree->size;++i)
	{
		print_ast_command(tree->pipeline[i]);
		printf(" | ");
	}
	printf("> PIPELINE_END");
}
void print_ast_machine(struct AST_Machine* tree)
{
	assert(tree);
	printf("MACHINE ");
	print_token(tree->id);
	printf(" [\n");
	print_ast_states(tree->states);
	print_ast_events(tree->events);
	print_ast_transitions(tree->transitions);
	printf("] MACHINE_END\n");
}
void print_ast_transitions(struct AST_Transitions* tree)
{
	size_t i;
	assert(tree);
	printf("TRANSITIONS [\n");
	for(i=0;i<tree->size;++i)
	{
		print_ast_transition(tree->transitions[i]);
		printf("\n");
	}
	printf("] TRANSITIONS_END\n");
}
void print_error(struct Error *error)
{
	assert(error);
	printf("Error: %s, line %ld row %ld\n",error->message,error->row,error->column);
}
void print_errors(struct Translation_Data *translation_data)
{
	struct Queue_Node *it;
	assert(translation_data);

	for(it=translation_data->errors->first;it!=NULL;it=it->prev)
	{
		print_error(it->data);
	}
}
void print_ast_translation_unit(struct AST_Translation_Unit *tree)
{
	size_t i;
	printf("TRANSLATION UNIT\n[\n");
	for(i=0;i<tree->number_of_machines;++i)
		print_ast_machine(tree->machines[i]);
	printf("\n] TRANSLATION UNIT END \n");
}
void print_ast_binary_expression(struct AST_Binary_Expression *tree)
{
	printf(" (");
	print_ast(tree->left);
	switch(tree->type)
	{
		case AST_TYPE_OP_AND:
			printf("&&");
			break;
		case AST_TYPE_OP_OR:
			printf("||");
			break;
		case AST_TYPE_OP_SELECTOR:
			printf(".");
			break;
		default:
			printf("?!!?!?!?");
	}
	print_ast(tree->right);
	printf(")");
}
void print_ast_unary_expression(struct AST_Unary_Expression *tree)
{
	printf("(!");
	print_ast(tree->operand);
	printf(")");
}
void print_ast_unchecked_state(struct AST_Unchecked_State *tree)
{
	print_token(tree->name);
}
void print_ast_if_statement(struct AST_If_Statement *tree)
{
	printf("if <");	
	print_ast(tree->condition);
	printf(">\n");
	print_ast(tree->body);
	if(tree->else_statement)
		print_ast(tree->else_statement);
}
#endif