class_name HInterface

var BOOLEAN_OPS: Array[String] = ["&&", "||", "!"]
var parser: Parser
var interp: HankInterp
var viewCounts: Variant

func _init(storyTree: StoryNode, viewCounts2: Variant) -> void:
	self.parser = Parser.new()

	if true:
		var op: String = "*"
		self.parser.opPriority.__set(op, -2)
	if true:
		var op: String = "&"
		self.parser.opPriority.__set(op, -2)
	if true:
		var op: String = "->"
		self.parser.opPriority.__set(op, -2)

	self.interp = HankInterp.new(self)

	if true:
		var v = func(v) -> bool:
			return HInterface.isTruthy(viewCounts2, v)
		self.interp.variables.__set("_isTruthy", v)
	if true:
		var v = func(val):
			return HInterface.valueOf(viewCounts2, val)
		self.interp.variables.__set("_valueOf", v)
	if true:
		var variables: Variant = self.interp.variables
		var v = func(name: String):
			return HInterface.resolveInScope(variables, name)
		self.interp.variables.__set("_resolve", v)
	if true:
		var variables: Variant = self.interp.variables
		var v = func(container, name: String):
			return HInterface.resolveField(variables, container, name)
		self.interp.variables.__set("_resolveField", v)

	self.viewCounts = viewCounts2

func setStory(story: Story) -> void:
	self.interp.setStory(story)

func addVariable(identifier: String, value) -> void:
	var this1: Variant = self.interp.variables

	this1.__set(identifier, value)

	value

func getVariable(identifier: String):
	var this1: Variant = self.interp.variables
	var tempResult = this1.__get(identifier)

	return tempResult

func runEmbeddedHaxe(h: String, scope: Array[Variant]) -> void:
	var this1: Variant = self.interp.variables

	this1.__set("scope", scope)

	scope
	var expr: Variant = self.parser.parseString(h, "hscript")

	expr = self.transmute(expr)
	self.interp.execute(expr)

func expr(h: String, scope: Array[Variant]):
	var this1: Variant = self.interp.variables

	this1.__set("scope", scope)

	scope
	var expr: Variant = self.parser.parseString(h, "hscript")

	expr = self.transmute(expr)

	var val = self.interp.expr(expr)

	if (val == null):
		assert(false, str("Expression " + h + " evaluated to null"))

	var val2 = HInterface.valueOf(self.viewCounts, val)

	return val2

func cond(h: String, scope: Array[Variant]) -> bool:
	var val = self.expr(h, scope)

	return HInterface.isTruthy(self.viewCounts, val)

func evaluateExpr(h: String, scope: Array[Variant]) -> String:
	return str(self.expr(h, scope))

func boolify(expr: Variant) -> Variant:
	var newExpr = self.transmute(expr)

	return { "_index": 8, "e": { "_index": 1, "v": "_isTruthy" }, "params": ([newExpr] as Array[Variant]) }

func valify(expr: Variant) -> Variant:
	return { "_index": 8, "e": { "_index": 1, "v": "_valueOf" }, "params": ([self.transmute(expr)] as Array[Variant]) }

func transmute(expr: Variant):
	if (expr == null):
		return null

	var tempResult

	match (expr._index):
		1:
			var _g: String = expr.v
			if true:
				var name: String = _g
				tempResult = { "_index": 8, "e": { "_index": 1, "v": "_resolve" }, "params": ([{ "_index": 0, "c": { "_index": 2, "s": name } }] as Array[Variant]) }
		2:
			var _g: String = expr.n
			var _g1 = expr.t
			var _g2 = expr.e
			if true:
				var name: String = _g
				var nested = _g2
				if true:
					if true:
						var this1: Variant = self.interp.variables
						var v = null
						this1.__set(name, v)
						v
					tempResult = { "_index": 6, "op": "=", "e1": { "_index": 1, "v": name }, "e2": self.transmute(nested) }
		3:
			var _g: Variant = expr.e
			if true:
				var nested: Variant = _g
				tempResult = { "_index": 3, "e": self.transmute(nested) }
		4:
			var _g: Array[Variant] = expr.e
			var nestedExpressions: Array[Variant] = _g
			var tempArray
			if true:
				var _g2: Array[Variant] = ([] as Array[Variant])
				if true:
					var _g1: int = 0
					while (_g1 < nestedExpressions.size()):
						var nested: Variant = nestedExpressions[_g1]
						_g1 += 1
						_g2.push_back(self.transmute(nested))
				tempArray = _g2
			tempResult = { "_index": 4, "e": tempArray }
		5:
			var _g: Variant = expr.e
			var _g1: String = expr.f
			if true:
				var nested: Variant = _g
				var f: String = _g1
				tempResult = { "_index": 8, "e": { "_index": 1, "v": "_resolveField" }, "params": ([self.transmute(nested), { "_index": 0, "c": { "_index": 2, "s": f } }] as Array[Variant]) }
		6:
			var _g: String = expr.op
			var _g1: Variant = expr.e1
			var _g2: Variant = expr.e2
			if true:
				var op: String = _g
				var e1: Variant = _g1
				var e2: Variant = _g2
				if (self.BOOLEAN_OPS.find(op) != -1):
					tempResult = { "_index": 6, "op": op, "e1": self.boolify(e1), "e2": self.boolify(e2) }
				else:
					if (op == "="):
						tempResult = { "_index": 6, "op": op, "e1": e1, "e2": e2 }
					else:
						tempResult = { "_index": 6, "op": op, "e1": self.valify(e1), "e2": self.valify(e2) }
		7:
			var _g: String = expr.op
			var _g1: bool = expr.prefix
			var _g2: Variant = expr.e
			if true:
				var op: String = _g
				var prefix: bool = _g1
				var e: Variant = _g2
				if (self.BOOLEAN_OPS.find(op) != -1):
					tempResult = { "_index": 7, "op": op, "prefix": prefix, "e": self.boolify(e) }
				else:
					tempResult = expr
		8:
			var _g: Variant = expr.e
			var _g1: Array[Variant] = expr.params
			if true:
				var e: Variant = _g
				var params: Array[Variant] = _g1
				if true:
					if (e._index == 5):
						var _g2: Variant = e.e
						var _g3: String = e.f
						if true:
							var innerE: Variant = _g2
							var f: String = _g3
							if true:
								var obj = self.interp.expr(innerE)
								if (obj != null):
									return expr
					else:
						pass
					var tempArray1
					if true:
						var _g2: Array[Variant] = ([] as Array[Variant])
						if true:
							var _g3: int = 0
							while (_g3 < params.size()):
								var ex: Variant = params[_g3]
								_g3 += 1
								_g2.push_back(self.transmute(ex))
						tempArray1 = _g2
					tempResult = { "_index": 8, "e": self.transmute(e), "params": tempArray1 }
		9:
			var _g: Variant = expr.cond
			var _g1: Variant = expr.e1
			var _g2 = expr.e2
			if true:
				var cond: Variant = _g
				var e1: Variant = _g1
				var e2 = _g2
				if true:
					if (e2 == null):
						e2 = { "_index": 0, "c": { "_index": 2, "s": "" } }
					tempResult = { "_index": 9, "cond": self.boolify(cond), "e1": self.transmute(e1), "e2": self.transmute(e2) }
		10:
			var _g: Variant = expr.cond
			var _g1: Variant = expr.e
			if true:
				var cond: Variant = _g
				var e: Variant = _g1
				tempResult = { "_index": 10, "cond": self.boolify(cond), "e": self.transmute(e) }
		11:
			var _g: String = expr.v
			var _g1: Variant = expr.it
			var _g2: Variant = expr.e
			if true:
				var v: String = _g
				var it: Variant = _g1
				var e: Variant = _g2
				tempResult = { "_index": 11, "v": v, "it": self.transmute(it), "e": self.transmute(e) }
		14:
			var _g: Array[Variant] = expr.args
			var _g1: Variant = expr.e
			var _g2 = expr.name
			var _g3 = expr.ret
			if true:
				var args: Array[Variant] = _g
				var e: Variant = _g1
				var name = _g2
				var ret = _g3
				tempResult = { "_index": 14, "args": args, "e": self.transmute(e), "name": name, "ret": ret }
		15:
			var _g = expr.e
			if true:
				var e = _g
				tempResult = { "_index": 15, "e": self.transmute(e) }
		16:
			var _g: Variant = expr.e
			var _g1: Variant = expr.index
			if true:
				var e: Variant = _g
				var index: Variant = _g1
				tempResult = { "_index": 16, "e": self.transmute(e), "index": self.transmute(index) }
		17:
			var _g: Array[Variant] = expr.e
			if true:
				var e: Array[Variant] = _g
				var tempArray2
				if true:
					var _g2: Array[Variant] = ([] as Array[Variant])
					if true:
						var _g1: int = 0
						while (_g1 < e.size()):
							var ex: Variant = e[_g1]
							_g1 += 1
							_g2.push_back(self.transmute(ex))
					tempArray2 = _g2
				tempResult = { "_index": 17, "e": tempArray2 }
		18:
			var _g: String = expr.cl
			var _g1: Array[Variant] = expr.params
			if true:
				var cl: String = _g
				var params: Array[Variant] = _g1
				var tempArray3
				if true:
					var _g2: Array[Variant] = ([] as Array[Variant])
					if true:
						var _g3: int = 0
						while (_g3 < params.size()):
							var ex: Variant = params[_g3]
							_g3 += 1
							_g2.push_back(self.transmute(ex))
					tempArray3 = _g2
				tempResult = { "_index": 18, "cl": cl, "params": tempArray3 }
		19:
			var _g: Variant = expr.e
			if true:
				var e: Variant = _g
				tempResult = { "_index": 19, "e": self.transmute(e) }
		20:
			var _g: Variant = expr.e
			var _g1: String = expr.v
			var _g2 = expr.t
			var _g3: Variant = expr.ecatch
			if true:
				var e: Variant = _g
				var v: String = _g1
				var t = _g2
				var ecatch: Variant = _g3
				tempResult = { "_index": 20, "e": self.transmute(e), "v": v, "t": t, "ecatch": self.transmute(ecatch) }
		21:
			var _g: Array[Variant] = expr.fl
			var fl: Array[Variant] = _g
			var tempArray4
			if true:
				var _g2: Array[Variant] = ([] as Array[Variant])
				if true:
					var _g1: int = 0
					while (_g1 < fl.size()):
						var pair: Variant = fl[_g1]
						_g1 += 1
						_g2.push_back({
							"name": pair.get("name"),
							"e": self.transmute(pair.get("e"))
						})
				tempArray4 = _g2
			tempResult = { "_index": 21, "fl": tempArray4 }
		22:
			var _g: Variant = expr.cond
			var _g1: Variant = expr.e1
			var _g2: Variant = expr.e2
			if true:
				var cond: Variant = _g
				var e1: Variant = _g1
				var e2: Variant = _g2
				tempResult = { "_index": 22, "cond": self.boolify(cond), "e1": self.transmute(e1), "e2": self.transmute(e2) }
		23:
			var _g: Variant = expr.e
			var _g1: Array[Variant] = expr.cases
			var _g2 = expr.defaultExpr
			if true:
				var e: Variant = _g
				var cases: Array[Variant] = _g1
				var defaultExpr = _g2
				var tempArray5
				if true:
					var _g3: Array[Variant] = ([] as Array[Variant])
					if true:
						var _g4: int = 0
						while (_g4 < cases.size()):
							var arm: Variant = cases[_g4]
							_g4 += 1
							var tempArray6
							if true:
								var _g5: Array[Variant] = ([] as Array[Variant])
								if true:
									var _g6: int = 0
									var _g7: Array[Variant] = arm.get("values")
									while (_g6 < _g7.size()):
										var value: Variant = _g7[_g6]
										_g6 += 1
										_g5.push_back(self.transmute(value))
								tempArray6 = _g5
							_g3.push_back({
								"values": tempArray6,
								"expr": self.transmute(arm.get("expr"))
							})
					tempArray5 = _g3
				tempResult = { "_index": 23, "e": self.transmute(e), "cases": tempArray5, "defaultExpr": self.transmute(defaultExpr) }
		24:
			var _g: Variant = expr.cond
			var _g1: Variant = expr.e
			if true:
				var cond: Variant = _g
				var e: Variant = _g1
				tempResult = { "_index": 24, "cond": self.boolify(cond), "e": self.transmute(e) }
		25:
			var _g: String = expr.name
			var _g1: Array[Variant] = expr.args
			var _g2: Variant = expr.e
			if true:
				var name: String = _g
				var args: Array[Variant] = _g1
				var e: Variant = _g2
				var tempArray7
				if true:
					var _g3: Array[Variant] = ([] as Array[Variant])
					if true:
						var _g4: int = 0
						while (_g4 < args.size()):
							var arg: Variant = args[_g4]
							_g4 += 1
							_g3.push_back(self.transmute(arg))
					tempArray7 = _g3
				tempResult = { "_index": 25, "name": name, "args": tempArray7, "e": self.transmute(e) }
		26:
			var _g: Variant = expr.e
			var _g1: Variant = expr.t
			if true:
				var e: Variant = _g
				var t: Variant = _g1
				tempResult = { "_index": 26, "e": self.transmute(e), "t": t }
		_:
			tempResult = expr

	return tempResult

static func resolveInScope(variables: Variant, name: String):
	var scope: Array[Variant] = (variables.__get("scope") as Array[Variant])
	var _g: int = 0

	while (_g < scope.size()):
		var container = scope[_g]
		_g += 1
		if true:
			var _g2: Variant = HInterface.resolve(variables, container, name)
			match (_g2._index):
				0:
					var _g3 = _g2.v
					var v = _g3
					return v
				1:
					pass

	assert(false, str("Could not resolve " + name + " in scope " + str(scope) + "."))

static func resolveField(variables: Variant, container, name: String):
	return Extensions.unwrap(HInterface.resolve(variables, container, name))

static func resolve(variables: Variant, container, name: String) -> Variant:
	if (variables.exists(name)):
		return { "_index": 0, "v": variables.__get(name) }
	else:
		if (((container as Variant) is StoryNode)):
			var node: StoryNode = (container as StoryNode)
			return node.resolve(name)
		else:
			var val = container.get(name)
			if (val != null):
				return { "_index": 0, "v": val }
			else:
				return { "_index": 1 }

static func isTruthy(viewCounts2: Variant, v) -> bool:
	if (((v as Variant) is StoryNode)):
		var node: StoryNode = (v as StoryNode)
		return viewCounts2.__get(node) > 0
	if (((v as Variant) is bool)):
		return v
	else:
		if (((v as Variant) is int) || ((v as Variant) is float)):
			return v > 0
		else:
			if (((v as Variant) is String)):
				if (v == "false"):
					return false
				else:
					return v.length > 0

	assert(false, str("" + str(v) + " cannot be coerced to a boolean"))

	return false

static func valueOf(viewCounts2: Variant, val):
	var tempResult

	if (((val as Variant) is StoryNode)):
		var node: StoryNode = (val as StoryNode)
		tempResult = viewCounts2.__get(node)
	else:
		tempResult = val

	return tempResult

static func viewCountOf(viewCounts2: Variant, val) -> Variant:
	var tempResult

	if (((val as Variant) is StoryNode)):
		var node: StoryNode = (val as StoryNode)
		tempResult = { "_index": 0, "v": viewCounts2.__get(node) }
	else:
		tempResult = { "_index": 1 }

	return tempResult