extends SceneTree

var failures: Array[String] = []
var intents: Array = []


func _init() -> void:
	_run.call_deferred()


func _run() -> void:
	var component_script: Script = load("res://scenes/components/input_component.gd")
	_expect(component_script != null, "InputComponent script should load")
	if component_script == null:
		_finish()
		return

	var component: Node = component_script.new()
	root.add_child(component)
	await process_frame
	_expect(component.has_signal("intent_created"), "InputComponent should expose intent_created")
	if component.has_signal("intent_created"):
		component.connect("intent_created", _on_intent_created)

	var expected := {
		KEY_A: [&"A", &"a"],
		KEY_D: [&"D", &"d"],
		KEY_W: [&"W", &"w"],
		KEY_S: [&"S", &"s"],
		KEY_SPACE: [&"SP", &"space"],
	}
	for key: Key in expected:
		var before := intents.size()
		var handled: bool = component.call("handle_input_event", _key_event(key, true, false, false))
		_expect_bool(handled, true, "%s keycode press should be handled" % OS.get_keycode_string(key))
		_expect_int(intents.size(), before + 1, "%s press intent count" % OS.get_keycode_string(key))
		if intents.size() == before + 1:
			_expect_string(str(intents[before].get("symbol")), str(expected[key][0]), "%s symbol" % OS.get_keycode_string(key))
			_expect_string(str(intents[before].get("rhythm_action")), str(expected[key][1]), "%s rhythm action" % OS.get_keycode_string(key))
			_expect_string(str(intents[before].get("event_type")), "pressed", "%s event type" % OS.get_keycode_string(key))
			_expect_bool(float(intents[before].get("timestamp_ms")) > 0.0, true, "%s timestamp" % OS.get_keycode_string(key))
		before = intents.size()
		handled = component.call("handle_input_event", _key_event(key, true, false, true))
		_expect_bool(handled, true, "%s physical key press should be handled" % OS.get_keycode_string(key))
		_expect_int(intents.size(), before + 1, "%s physical press intent count" % OS.get_keycode_string(key))

	var echo_count := intents.size()
	var echo_handled: bool = component.call("handle_input_event", _key_event(KEY_A, true, true, false))
	_expect_bool(echo_handled, false, "echo press should not be handled")
	_expect_int(intents.size(), echo_count, "echo press should not emit intent")

	var release_handled: bool = component.call("handle_input_event", _key_event(KEY_A, false, false, false))
	_expect_bool(release_handled, true, "A release should be handled")
	_expect_string(str(intents[intents.size() - 1].get("event_type")), "released", "release event type")
	_expect_string(str(intents[intents.size() - 1].get("symbol")), "A", "release symbol")
	component.free()
	_finish()


func _on_intent_created(intent) -> void:
	intents.append(intent)


func _key_event(key: Key, pressed: bool, echo: bool, physical_only: bool) -> InputEventKey:
	var event := InputEventKey.new()
	event.keycode = KEY_NONE if physical_only else key
	event.physical_keycode = key if physical_only else KEY_NONE
	event.pressed = pressed
	event.echo = echo
	return event


func _expect(condition: bool, label: String) -> void:
	if not condition:
		failures.append(label)


func _expect_bool(actual: bool, expected: bool, label: String) -> void:
	if actual != expected:
		failures.append("%s: expected %s, got %s" % [label, expected, actual])


func _expect_int(actual: int, expected: int, label: String) -> void:
	if actual != expected:
		failures.append("%s: expected %d, got %d" % [label, expected, actual])


func _expect_string(actual: String, expected: String, label: String) -> void:
	if actual != expected:
		failures.append("%s: expected %s, got %s" % [label, expected, actual])


func _finish() -> void:
	if failures.is_empty():
		print("PASS input component intents")
		quit(0)
	else:
		for failure: String in failures:
			push_error(failure)
		quit(1)