include "primitives.alh"
include "conformance_scd.alh"
include "library.alh"
include "io.alh"

Element while_stack = ?

Element function construct_top():
	String command
	command = input()
	if (command == "global"):
		return construct_top_global()
	elif (command == "funcdef"):
		return construct_top_funcdef()
	else:
		log("ERROR: did not understand command " + cast_e2s(command))

Element function construct_top_global():
	Element this_element
	String declared_element
	String op

	this_element = create_value(!global)
	declared_element = input()
	dict_add(this_element, "var", declared_element)

	// Defines
	Element assign
	Element resolve
	Element value
	assign = create_value(!assign)
	dict_add(this_element, "next", assign)
	resolve = create_value(!resolve)
	dict_add(assign, "var", resolve)
	dict_add(resolve, "var", declared_element)
	op = input()
	value = create_value(!constant)
	if (op == "deref"):
		dict_add(value, "node", import_node(input()))
	elif (op == "empty"):
		dict_add(value, "node", create_node())
	elif (op == "const"):
		dict_add(value, "node", input())
	dict_add(assign, "value", value)

	if (input()):
		dict_add(assign, "next", construct_top())
	return this_element

Element function construct_top_funcdef():
	Element assign
	Element resolve
	Element constant
	Element formal
	Element func
	Element params
	Element global

	global = create_value(!global)
	assign = create_value(!assign)
	resolve = create_value(!resolve)
	constant = create_value(!constant)
	formal = input()
	func = create_node()
	params = create_node()
	dict_add(global, "var", formal)
	dict_add(global, "next", assign)
	dict_add(assign, "var", resolve)
	dict_add(assign, "value", constant)
	dict_add(resolve, "var", formal)
	dict_add(constant, "node", func)
	dict_add(func, "params", params)

	Integer nrParams
	nrParams = input()
	Integer counter
	counter = 0
	Element param

	String arg_names_decl
	arg_names_decl = "abcdefghijklmnopqrstuvwxyz"

	while (counter < nrParams):
		param = create_node()
		dict_add(params, string_get(arg_names_decl, counter), param)
		output(param)
		// Output each parameter in turn
		counter = counter + 1

	// Now add the body
	dict_add(func, "body", construct_unknown())

	if (input()):
		dict_add(assign, "next", construct_top())

	return global

Element function construct_unknown():
	String elem
	Element new_model
	Element new_model_model
	elem = input()

	if (elem == "if"):
		return construct_if()
	elif (elem == "while"):
		return construct_while()
	elif (elem == "access"):
		return construct_access()
	elif (elem == "resolve"):
		return construct_resolve()
	elif (elem == "assign"):
		return construct_assign()
	elif (elem == "call"):
		return construct_call()
	elif (elem == "return"):
		return construct_return()
	elif (elem == "const"):
		return construct_const()
	elif (elem == "declare"):
		return construct_declare()
	elif (elem == "global"):
		return construct_global()
	elif (elem == "funcdef"):
		return construct_funcdef()
	elif (elem == "output"):
		return construct_output()
	elif (elem == "input"):
		return construct_input()
	elif (elem == "deref"):
		return construct_deref()
	elif (elem == "break"):
		return construct_break()
	elif (elem == "continue"):
		return construct_continue()
	elif (elem == "tag"):
		Element tmp_constructed
		tmp_constructed = construct_unknown()
		output(tmp_constructed)
		return tmp_constructed
	elif (elem == "instantiate_bottom"):
		new_model = create_node()
		dict_add(new_model, "model", create_node())
		instantiate_bottom(new_model)
		output(new_model)
		return construct_unknown()
	elif (elem == "instantiate_model"):
		new_model = instantiate_new_model(input(), dict_read(dict_read(input(), "model"), input()))
		instantiate_model(new_model)
		output(new_model)
		return construct_unknown()
	elif (elem == "retype_model"):
		retype_model(input())
		return construct_unknown()
	else:
		log("ERROR: did not understand command " + cast_e2s(elem))

Element function construct_if():
	Element this_element
	this_element = create_value(!if)
	dict_add(this_element, "cond", construct_unknown())
	dict_add(this_element, "then", construct_unknown())
	if (input()):
		dict_add(this_element, "else", construct_unknown())
	if (input()):
		dict_add(this_element, "next", construct_unknown())
	return this_element

Element function construct_while():
	Element this_element
	this_element = create_value(!while)
	dict_add(this_element, "cond", construct_unknown())

	list_append(while_stack, this_element)
	dict_add(this_element, "body", construct_unknown())
	list_delete(while_stack, list_len(while_stack) - 1)

	if (input()):
		dict_add(this_element, "next", construct_unknown())
	return this_element

Element function construct_access():
	Element this_element
	this_element = create_value(!access)
	dict_add(this_element, "var", construct_unknown())
	return this_element

Element function construct_resolve():
	Element this_element
	this_element = create_value(!resolve)
	dict_add(this_element, "var", input())
	return this_element

Element function construct_assign():
	Element this_element
	this_element = create_value(!assign)
	dict_add(this_element, "var", construct_unknown())
	dict_add(this_element, "value", construct_unknown())
	if (input()):
		dict_add(this_element, "next", construct_unknown())
	return this_element

Element function construct_call():
	Element this_element
	this_element = create_value(!call)
	dict_add(this_element, "func", construct_unknown())

	Integer nrParams
	nrParams = input()
	Integer counter
	counter = 0

	Element param
	Element prev_param
	String arg_names_call
	arg_names_call = "abcdefghijklmnopqrstuvwxyz"

	while (counter < nrParams):
		param = create_node()

		dict_add(param, "name", string_get(arg_names_call, counter))
		dict_add(param, "value", construct_unknown())

		if (counter == 0):
			dict_add(this_element, "params", param)
		else:
			dict_add(prev_param, "next_param", param)
		prev_param = param

		counter = counter + 1

	if (nrParams > 0):
		dict_add(this_element, "last_param", prev_param)

	if (input()):
		dict_add(this_element, "next", construct_unknown())
	return this_element

Element function construct_return():
	Element this_element
	this_element = create_value(!return)
	if (input()):
		dict_add(this_element, "value", construct_unknown())
	return this_element

Element function construct_const():
	Element this_element
	this_element = create_value(!constant)
	dict_add(this_element, "node", input())
	return this_element

Element function construct_declare():
	Element this_element
	Element declared_element
	this_element = create_value(!declare)
	declared_element = create_node()
	dict_add(this_element, "var", declared_element)
	output(declared_element)
	if (input()):
		dict_add(this_element, "next", construct_unknown())
	return this_element

// TODO remove global keyword
Element function construct_global():
	Element this_element
	String declared_element
	this_element = create_value(!global)
	declared_element = input()
	dict_add(this_element, "var", declared_element)
	if (input()):
		dict_add(this_element, "next", construct_unknown())
	return this_element

Element function construct_input():
	Element this_element
	this_element = create_value(!input)
	return this_element

Element function construct_output():
	Element this_element
	this_element = create_value(!output)
	dict_add(this_element, "value", construct_unknown())
	if (input()):
		dict_add(this_element, "next", construct_unknown())
	return this_element

Element function construct_deref():
	Element this_element
	this_element = create_value(!constant)
	dict_add(this_element, "node", import_node(input()))
	return this_element

Element function construct_funcdef():
	Element assign
	Element resolve
	Element constant
	Element formal
	Element func
	Element params

	assign = create_value(!assign)
	resolve = create_value(!resolve)
	constant = create_value(!constant)
	formal = input()
	func = create_node()
	params = create_node()
	dict_add(assign, "var", resolve)
	dict_add(assign, "value", constant)
	dict_add(resolve, "var", formal)
	dict_add(constant, "node", func)
	dict_add(func, "params", params)

	Integer nrParams
	nrParams = input()
	Integer counter
	counter = 0
	Element param

	String arg_names_decl
	arg_names_decl = "abcdefghijklmnopqrstuvwxyz"

	while (counter < nrParams):
		param = create_node()
		dict_add(params, string_get(arg_names_decl, counter), param)
		output(param)
		// Output each parameter in turn
		counter = counter + 1

	// Now add the body
	dict_add(func, "body", construct_unknown())

	if (input()):
		dict_add(assign, "next", construct_unknown())

	return assign

Element function construct_break():
	Element this_element
	this_element = create_value(!break)
	dict_add(this_element, "while", dict_read(while_stack, list_len(while_stack) - 1))
	return this_element

Element function construct_continue():
	Element this_element
	this_element = create_value(!continue)
	dict_add(this_element, "while", dict_read(while_stack, list_len(while_stack) - 1))
	return this_element

Element function instantiate_bottom(model : Element):
	Element this_element
	String bottom_type
	bottom_type = input()
	String element_name
	element_name = input()

	// Find out which kind of element we want to create
	if (bottom_type == "node"):
		instantiate_bottom_node(model, element_name)
	elif (bottom_type == "value"):
		instantiate_bottom_value(model, element_name, input())
	elif (bottom_type == "edge"):
		instantiate_bottom_edge(model, element_name, dict_read(dict_read(model, "model"), input()), dict_read(dict_read(model, "model"), input()))

	// If there is more to come, we also add these elements
	if (input()):
		return instantiate_bottom(model)
	else:
		return model

Element function instantiate_model(model : Element):
	Element type
	type = dict_read(dict_read(dict_read(model, "metamodel"), "model"), input())

	Element name
	name = input()

	Element params
	params = create_node()
	if (is_edge(type)):
		list_append(params, dict_read(dict_read(model, "model"), input()))
		list_append(params, dict_read(dict_read(model, "model"), input()))
	elif (type_eq(typeof(type), Type)):
		list_append(params, input())

	Element attribute_types
	attribute_types = create_node()
	while (input()):
		dict_add(attribute_types, input(), input())

	Element attribute_instances
	attribute_instances = create_node()
	while (input()):
		dict_add(attribute_instances, input(), input())

	instantiate_model_lib(model, type, name, params, attribute_types, attribute_instances)

	if (input()):
		instantiate_model(model)
	
	return 1

Element function retype_model(model : Element):
	Element metamodel
	metamodel = input()

	Element inheritance
	inheritance = dict_read(dict_read(input(), "model"), input())

	Element mapping
	mapping = create_node()
	while (input()):
		dict_add(mapping, dict_read(dict_read(model, "model"), input()), dict_read(dict_read(metamodel, "model"), input()))

	return retype(model, metamodel, inheritance, mapping)

Element function find_attribute(source : Element, attr_name : Element, types : Element, inheritance_link : Element):
	if (dict_in(source, attr_name)):
		return source
	else:
		Integer counter
		Integer i
		Element edge
		counter = read_nr_out(source)
		i = 0
		while (i < counter):
			edge = read_out(source, i)
			if (element_eq(dict_read_node(types, edge), inheritance_link)):
				return find_attribute(read_edge_dst(edge), attr_name, types, inheritance_link)
			i = i + 1
		// No return at the moment, as this crashes the MvK