class_name haxe_ds_BalancedTree

var root: haxe_ds_TreeNode

func _init() -> void:
	pass

func __set(key, value) -> void:
	self.root = self.setLoop(key, value, self.root)

func __get(key):
	var node: haxe_ds_TreeNode = self.root

	while (node != null):
		var c: int = self.compare(key, node.key)
		if (c == 0):
			return node.value
		if (c < 0):
			node = node.left
		else:
			node = node.right

	return null

func keys() -> Variant:
	var ret: Array[Variant] = ([] as Array[Variant])

	self.keysLoop(self.root, ret)

	return haxe_iterators_ArrayIterator.new(ret)

func setLoop(k, v, node: haxe_ds_TreeNode) -> haxe_ds_TreeNode:
	if (node == null):
		return haxe_ds_TreeNode.new(null, k, v, null)

	var c: int = self.compare(k, node.key)
	var tempResult

	if (c == 0):
		var tempNumber
		if (node == null):
			tempNumber = 0
		else:
			tempNumber = node._height
		tempResult = haxe_ds_TreeNode.new(node.left, k, v, node.right, tempNumber)
	else:
		if (c < 0):
			var nl: haxe_ds_TreeNode = self.setLoop(k, v, node.left)
			tempResult = self.balance(nl, node.key, node.value, node.right)
		else:
			var nr: haxe_ds_TreeNode = self.setLoop(k, v, node.right)
			tempResult = self.balance(node.left, node.key, node.value, nr)

	return tempResult

func keysLoop(node: haxe_ds_TreeNode, acc: Array[Variant]) -> void:
	if (node != null):
		self.keysLoop(node.left, acc)
		acc.push_back(node.key)
		self.keysLoop(node.right, acc)

func balance(l: haxe_ds_TreeNode, k, v, r: haxe_ds_TreeNode) -> haxe_ds_TreeNode:
	var tempNumber

	if (l == null):
		tempNumber = 0
	else:
		tempNumber = l._height

	var hl: int = tempNumber
	var tempNumber1

	if (r == null):
		tempNumber1 = 0
	else:
		tempNumber1 = r._height

	var hr: int = tempNumber1
	var tempResult

	if (hl > hr + 2):
		var tempLeft
		if true:
			var _this: haxe_ds_TreeNode = l.left
			if (_this == null):
				tempLeft = 0
			else:
				tempLeft = _this._height
		var tempRight
		if true:
			var _this: haxe_ds_TreeNode = l.right
			if (_this == null):
				tempRight = 0
			else:
				tempRight = _this._height
		if (tempLeft >= tempRight):
			tempResult = haxe_ds_TreeNode.new(l.left, l.key, l.value, haxe_ds_TreeNode.new(l.right, k, v, r))
		else:
			tempResult = haxe_ds_TreeNode.new(haxe_ds_TreeNode.new(l.left, l.key, l.value, l.right.left), l.right.key, l.right.value, haxe_ds_TreeNode.new(l.right.right, k, v, r))
	else:
		if (hr > hl + 2):
			var tempLeft1
			if true:
				var _this: haxe_ds_TreeNode = r.right
				if (_this == null):
					tempLeft1 = 0
				else:
					tempLeft1 = _this._height
			var tempRight1
			if true:
				var _this: haxe_ds_TreeNode = r.left
				if (_this == null):
					tempRight1 = 0
				else:
					tempRight1 = _this._height
			if (tempLeft1 > tempRight1):
				tempResult = haxe_ds_TreeNode.new(haxe_ds_TreeNode.new(l, k, v, r.left), r.key, r.value, r.right)
			else:
				tempResult = haxe_ds_TreeNode.new(haxe_ds_TreeNode.new(l, k, v, r.left.left), r.left.key, r.left.value, haxe_ds_TreeNode.new(r.left.right, r.key, r.value, r.right))
		else:
			var tempNumber2
			if (hl > hr):
				tempNumber2 = hl
			else:
				tempNumber2 = hr
			tempResult = haxe_ds_TreeNode.new(l, k, v, r, (tempNumber2) + 1)

	return tempResult

func compare(k1, k2) -> int:
	return Reflect.compare(k1, k2)