class_name GdAssertMessages
extends Resource

const WARN_COLOR = "#EFF883"
const ERROR_COLOR = "#CD5C5C"
const VALUE_COLOR = "#1E90FF"
const SUB_COLOR :=  Color(1, 0, 0, .15)
const ADD_COLOR :=  Color(0, 1, 0, .15)


# Dictionary of control characters and their readable representations
const CONTROL_CHARS = {
	"\n": "<LF>",   # Line Feed
	"\r": "<CR>",   # Carriage Return
	"\t": "<TAB>",  # Tab
	"\b": "<BS>",   # Backspace
	"\f": "<FF>",   # Form Feed
	"\v": "<VT>",   # Vertical Tab
	"\a": "<BEL>",  # Bell
	"": "<ESC>"   # Escape
}


static func format_dict(value :Variant) -> String:
	if not value is Dictionary:
		return str(value)

	var dict_value: Dictionary = value
	if dict_value.is_empty():
		return "{ }"
	var as_rows := var_to_str(value).split("\n")
	for index in range( 1, as_rows.size()-1):
		as_rows[index] = "	" + as_rows[index]
	as_rows[-1] = "  " + as_rows[-1]
	return "\n".join(as_rows)


# improved version of InputEvent as text
static func input_event_as_text(event :InputEvent) -> String:
	var text := ""
	if event is InputEventKey:
		var key_event := event as InputEventKey
		text += """
			InputEventKey : keycode=%s (%s) pressed: %s
				physical_keycode: %s
				location: %s
				echo: %s""" % [
					key_event.keycode,
					key_event.as_text_keycode(),
					key_event.pressed,
					key_event.physical_keycode,
					key_event.location,
					key_event.echo]
	else:
		text += event.as_text()
	if event is InputEventMouse:
		var mouse_event := event as InputEventMouse
		text += """
				global_position: %s""" % mouse_event.global_position
	if event is InputEventWithModifiers:
		var mouse_event := event as InputEventWithModifiers
		text += """
				--------
				mods: %s
				shift: %s
				alt: %s
				control: %s
				meta: %s
				command: %s""" % [
					mouse_event.get_modifiers_mask(),
					mouse_event.shift_pressed,
					mouse_event.alt_pressed,
					mouse_event.ctrl_pressed,
					mouse_event.meta_pressed,
					mouse_event.command_or_control_autoremap]
	return text.dedent()


static func _colored_string_div(characters: String) -> String:
	return colored_array_div(characters.to_utf32_buffer().to_int32_array())


static func colored_array_div(characters: PackedInt32Array) -> String:
	if characters.is_empty():
		return "<empty>"
	var result := PackedInt32Array()
	var index := 0
	var missing_chars := PackedInt32Array()
	var additional_chars := PackedInt32Array()

	while index < characters.size():
		var character := characters[index]
		match character:
			GdDiffTool.DIV_ADD:
				index += 1
				@warning_ignore("return_value_discarded")
				additional_chars.append(characters[index])
			GdDiffTool.DIV_SUB:
				index += 1
				@warning_ignore("return_value_discarded")
				missing_chars.append(characters[index])
			_:
				if not missing_chars.is_empty():
					result.append_array(format_chars(missing_chars, SUB_COLOR))
					missing_chars = PackedInt32Array()
				if not additional_chars.is_empty():
					result.append_array(format_chars(additional_chars, ADD_COLOR))
					additional_chars = PackedInt32Array()
				@warning_ignore("return_value_discarded")
				result.append(character)
		index += 1

	result.append_array(format_chars(missing_chars, SUB_COLOR))
	result.append_array(format_chars(additional_chars, ADD_COLOR))
	return result.to_byte_array().get_string_from_utf32()


static func _typed_value(value :Variant) -> String:
	return GdDefaultValueDecoder.decode(value)


static func _warning(error :String) -> String:
	return "[color=%s]%s[/color]" % [WARN_COLOR, error]


static func _error(error :String) -> String:
	return "[color=%s]%s[/color]" % [ERROR_COLOR, error]


static func _nerror(number :Variant) -> String:
	match typeof(number):
		TYPE_INT:
			return "[color=%s]%d[/color]" % [ERROR_COLOR, number]
		TYPE_FLOAT:
			return "[color=%s]%f[/color]" % [ERROR_COLOR, number]
		_:
			return "[color=%s]%s[/color]" % [ERROR_COLOR, str(number)]


static func _colored(value: Variant, color: Color) -> String:
	return "[color=%s]%s[/color]" % [color.to_html(), value]


static func _colored_value(value :Variant) -> String:
	match typeof(value):
		TYPE_STRING, TYPE_STRING_NAME:
			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _colored_string_div(str(value))]
		TYPE_INT:
			return "'[color=%s]%d[/color]'" % [VALUE_COLOR, value]
		TYPE_FLOAT:
			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _typed_value(value)]
		TYPE_COLOR:
			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _typed_value(value)]
		TYPE_OBJECT:
			if value == null:
				return "'[color=%s]<null>[/color]'" % [VALUE_COLOR]
			if value is InputEvent:
				var ie: InputEvent = value
				return "[color=%s]<%s>[/color]" % [VALUE_COLOR, input_event_as_text(ie)]
			var obj_value: Object = value
			if obj_value.has_method("_to_string"):
				return "[color=%s]<%s>[/color]" % [VALUE_COLOR, str(value)]
			return "[color=%s]<%s>[/color]" % [VALUE_COLOR, obj_value.get_class()]
		TYPE_DICTIONARY:
			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, format_dict(value)]
		_:
			if GdArrayTools.is_array_type(value):
				return "'[color=%s]%s[/color]'" % [VALUE_COLOR, _typed_value(value)]
			return "'[color=%s]%s[/color]'" % [VALUE_COLOR, value]



static func _index_report_as_table(index_reports :Array) -> String:
	var table := "[table=3]$cells[/table]"
	var header := "[cell][right][b]$text[/b][/right]\t[/cell]"
	var cell := "[cell][right]$text[/right]\t[/cell]"
	var cells := header.replace("$text", "Index") + header.replace("$text", "Current") + header.replace("$text", "Expected")
	for report :Variant in index_reports:
		var index :String = str(report["index"])
		var current :String = str(report["current"])
		var expected :String = str(report["expected"])
		cells += cell.replace("$text", index) + cell.replace("$text", current) + cell.replace("$text", expected)
	return table.replace("$cells", cells)



static func orphan_warning(orphans_count: int) -> String:
	return """
		%s: Found %s possible orphan nodes.
			Add %s to the end of the test to collect details.""".dedent().trim_prefix("\n") % [
		_warning("WARNING:"),
		_nerror(orphans_count),
		_colored_value("collect_orphan_node_details()")
	]

static func orphan_detected_on_suite_setup(orphans: Array[GdUnitOrphanNodeInfo]) -> String:
	return """
		%s Detected %s orphan nodes!
			[b]Verify your test suite setup.[/b]
		%s""".dedent().trim_prefix("\n") % [
		_warning("WARNING:"),
		_nerror(orphans.size()),
		_build_orphan_node_stacktrace(orphans)]


static func orphan_detected_on_test_setup(orphans: Array[GdUnitOrphanNodeInfo]) -> String:
	return """
			%s Detected %s orphan nodes on test setup!
				[b]Check before_test() and after_test()![/b]
			%s""".dedent().trim_prefix("\n") % [
				_warning("WARNING:"),
				_nerror(orphans.size()),
				_build_orphan_node_stacktrace(orphans)
			]


static func orphan_detected_on_test(orphans: Array[GdUnitOrphanNodeInfo]) -> String:
	return """
		%s Detected %s orphan nodes!
		%s""".dedent().trim_prefix("\n") % [
			_warning("WARNING:"),
			_nerror(orphans.size()),
			_build_orphan_node_stacktrace(orphans)
		]


static func _build_orphan_node_stacktrace(orphans: Array[GdUnitOrphanNodeInfo]) -> String:
	var stack_trace := "\n"
	for orphan in orphans:
		stack_trace += orphan.as_trace(orphan, true) + "\n"
	return stack_trace.indent("    ")



static func fuzzer_interuped(iterations: int, error: String) -> String:
	return "%s %s %s\n %s" % [
		_error("Found an error after"),
		_colored_value(iterations + 1),
		_error("test iterations"),
		error]


static func test_timeout(timeout :int) -> String:
	return "%s\n %s" % [_error("Timeout !"), _colored_value("Test timed out after %s" %  LocalTime.elapsed(timeout))]


static func test_session_terminated() -> String:
	return "%s" % _error("Test Session Terminated")


# gdlint:disable = mixed-tabs-and-spaces
static func test_suite_skipped(hint :String, skip_count :int) -> String:
	return """
		%s
		  Skipped %s tests
		  Reason: %s
		""".dedent().trim_prefix("\n")\
		% [_error("The Entire test-suite is skipped!"), _colored_value(skip_count), _colored_value(hint)]


static func test_skipped(hint :String) -> String:
	return """
		%s
		  Reason: %s
		""".dedent().trim_prefix("\n")\
		% [_error("This test is skipped!"), _colored_value(hint)]


static func error_not_implemented() -> String:
	return _error("Test not implemented!")


static func error_is_null(current :Variant) -> String:
	return "%s %s but was %s" % [_error("Expecting:"), _colored_value(null), _colored_value(current)]


static func error_is_not_null() -> String:
	return "%s %s" % [_error("Expecting: not to be"), _colored_value(null)]


static func error_equal(current :Variant, expected :Variant, index_reports :Array = []) -> String:
	var report := """
		%s
		 %s
		 but was
		 %s""".dedent().trim_prefix("\n") % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]
	if not index_reports.is_empty():
		report += "\n\n%s\n%s" % [_error("Differences found:"), _index_report_as_table(index_reports)]
	return report


static func error_not_equal(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n not equal to\n %s" % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]


static func error_not_equal_case_insensetiv(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n not equal to (case insensitiv)\n %s" % [
			_error("Expecting:"), _colored_value(expected), _colored_value(current)]


static func error_is_empty(current :Variant) -> String:
	return "%s\n must be empty but was\n %s" % [_error("Expecting:"), _colored_value(current)]


static func error_is_not_empty() -> String:
	return "%s\n must not be empty" % [_error("Expecting:")]


static func error_is_same(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n to refer to the same object\n %s" % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]


@warning_ignore("unused_parameter")
static func error_not_same(_current :Variant, expected :Variant) -> String:
	return "%s\n %s" % [_error("Expecting not same:"), _colored_value(expected)]


static func error_not_same_error(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n but was\n %s" % [_error("Expecting error message:"), _colored_value(expected), _colored_value(current)]


static func error_is_instanceof(current: GdUnitResult, expected :GdUnitResult) -> String:
	return "%s\n %s\n But it was %s" % [_error("Expected instance of:"),\
		_colored_value(expected.or_else(null)), _colored_value(current.or_else(null))]


# -- Boolean Assert specific messages -----------------------------------------------------
static func error_is_true(current :Variant) -> String:
	return "%s %s but is %s" % [_error("Expecting:"), _colored_value(true), _colored_value(current)]


static func error_is_false(current :Variant) -> String:
	return "%s %s but is %s" % [_error("Expecting:"), _colored_value(false), _colored_value(current)]


# - Integer/Float Assert specific messages -----------------------------------------------------

static func error_is_even(current :Variant) -> String:
	return "%s\n %s must be even" % [_error("Expecting:"), _colored_value(current)]


static func error_is_odd(current :Variant) -> String:
	return "%s\n %s must be odd" % [_error("Expecting:"), _colored_value(current)]


static func error_is_negative(current :Variant) -> String:
	return "%s\n %s be negative" % [_error("Expecting:"), _colored_value(current)]


static func error_is_not_negative(current :Variant) -> String:
	return "%s\n %s be not negative" % [_error("Expecting:"), _colored_value(current)]


static func error_is_zero(current :Variant) -> String:
	return "%s\n equal to 0 but is %s" % [_error("Expecting:"), _colored_value(current)]


static func error_is_not_zero() -> String:
	return "%s\n not equal to 0" % [_error("Expecting:")]


static func error_is_wrong_type(current_type :Variant.Type, expected_type :Variant.Type) -> String:
	return "%s\n Expecting type %s but is %s" % [
		_error("Unexpected type comparison:"),
		_colored_value(GdObjects.type_as_string(current_type)),
		_colored_value(GdObjects.type_as_string(expected_type))]


static func error_is_value(operation :int, current :Variant, expected :Variant, expected2 :Variant = null) -> String:
	match operation:
		Comparator.EQUAL:
			return "%s\n %s but was '%s'" % [_error("Expecting:"), _colored_value(expected), _nerror(current)]
		Comparator.LESS_THAN:
			return "%s\n %s but was '%s'" % [_error("Expecting to be less than:"), _colored_value(expected), _nerror(current)]
		Comparator.LESS_EQUAL:
			return "%s\n %s but was '%s'" % [_error("Expecting to be less than or equal:"), _colored_value(expected), _nerror(current)]
		Comparator.GREATER_THAN:
			return "%s\n %s but was '%s'" % [_error("Expecting to be greater than:"), _colored_value(expected), _nerror(current)]
		Comparator.GREATER_EQUAL:
			return "%s\n %s but was '%s'" % [_error("Expecting to be greater than or equal:"), _colored_value(expected), _nerror(current)]
		Comparator.BETWEEN_EQUAL:
			return "%s\n %s\n in range between\n %s <> %s" % [
					_error("Expecting:"), _colored_value(current), _colored_value(expected), _colored_value(expected2)]
		Comparator.NOT_BETWEEN_EQUAL:
			return "%s\n %s\n not in range between\n %s <> %s" % [
					_error("Expecting:"), _colored_value(current), _colored_value(expected), _colored_value(expected2)]
	return "TODO create expected message"


static func error_is_in(current :Variant, expected :Array) -> String:
	return "%s\n %s\n is in\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(str(expected))]


static func error_is_not_in(current :Variant, expected :Array) -> String:
	return "%s\n %s\n is not in\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(str(expected))]


# - StringAssert ---------------------------------------------------------------------------------
static func error_equal_ignoring_case(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n but was\n %s (ignoring case)" % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]


static func error_contains(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n do contains\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]


static func error_not_contains(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n not do contain\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]


static func error_contains_ignoring_case(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n contains\n %s\n (ignoring case)" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]


static func error_not_contains_ignoring_case(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n not do contains\n %s\n (ignoring case)" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]


static func error_starts_with(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n to start with\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]


static func error_ends_with(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n to end with\n %s" % [_error("Expecting:"), _colored_value(current), _colored_value(expected)]


static func error_has_length(current :Variant, expected: int, compare_operator :int) -> String:
	@warning_ignore("unsafe_method_access")
	var current_length :Variant = current.length() if current != null else null
	match compare_operator:
		Comparator.EQUAL:
			return "%s\n %s but was '%s' in\n %s" % [
					_error("Expecting size:"), _colored_value(expected), _nerror(current_length), _colored_value(current)]
		Comparator.LESS_THAN:
			return "%s\n %s but was '%s' in\n %s" % [
					_error("Expecting size to be less than:"), _colored_value(expected), _nerror(current_length), _colored_value(current)]
		Comparator.LESS_EQUAL:
			return "%s\n %s but was '%s' in\n %s" % [
					_error("Expecting size to be less than or equal:"), _colored_value(expected),
					_nerror(current_length), _colored_value(current)]
		Comparator.GREATER_THAN:
			return "%s\n %s but was '%s' in\n %s" % [
					_error("Expecting size to be greater than:"), _colored_value(expected),
					_nerror(current_length), _colored_value(current)]
		Comparator.GREATER_EQUAL:
			return "%s\n %s but was '%s' in\n %s" % [
					_error("Expecting size to be greater than or equal:"), _colored_value(expected),
					_nerror(current_length), _colored_value(current)]
	return "TODO create expected message"


# - ArrayAssert specific messgaes ---------------------------------------------------

static func error_arr_contains(current: Variant, expected: Variant, not_expect: Variant, not_found: Variant, by_reference: bool) -> String:
	var failure_message := "Expecting contains SAME elements:" if by_reference else "Expecting contains elements:"
	var error := "%s\n %s\n do contains (in any order)\n %s" % [
					_error(failure_message), _colored_value(current), _colored_value(expected)]
	if not is_empty(not_expect):
		error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect)
	if not is_empty(not_found):
		var prefix := "but" if is_empty(not_expect) else "and"
		error += "\n%s could not find elements:\n %s" % [prefix, _colored_value(not_found)]
	return error


static func error_arr_contains_exactly(
	current: Variant,
	expected: Variant,
	not_expect: Variant,
	not_found: Variant, compare_mode: GdObjects.COMPARE_MODE) -> String:
	var failure_message := (
		"Expecting contains exactly elements:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
		else "Expecting contains SAME exactly elements:"
	)
	if is_empty(not_expect) and is_empty(not_found):
		var arr_current: Array = current
		var arr_expected: Array = expected
		var diff := _find_first_diff(arr_current, arr_expected)
		return "%s\n %s\n do contains (in same order)\n %s\n but has different order %s"  % [
					_error(failure_message), _colored_value(current), _colored_value(expected), diff]

	var error := "%s\n %s\n do contains (in same order)\n %s" % [
					_error(failure_message), _colored_value(current), _colored_value(expected)]
	if not is_empty(not_expect):
		error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect)
	if not is_empty(not_found):
		var prefix := "but" if is_empty(not_expect) else "and"
		error += "\n%s could not find elements:\n %s" % [prefix, _colored_value(not_found)]
	return error


static func error_arr_contains_exactly_in_any_order(
	current: Variant,
	expected: Variant,
	not_expect: Variant,
	not_found: Variant,
	compare_mode: GdObjects.COMPARE_MODE) -> String:

	var failure_message := (
		"Expecting contains exactly elements:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
		else "Expecting contains SAME exactly elements:"
	)
	var error := "%s\n %s\n do contains exactly (in any order)\n %s" % [
					_error(failure_message), _colored_value(current), _colored_value(expected)]
	if not is_empty(not_expect):
		error += "\nbut some elements where not expected:\n %s" % _colored_value(not_expect)
	if not is_empty(not_found):
		var prefix := "but" if is_empty(not_expect) else "and"
		error += "\n%s could not find elements:\n %s" % [prefix, _colored_value(not_found)]
	return error


static func error_arr_not_contains(current: Variant, expected: Variant, found: Variant, compare_mode: GdObjects.COMPARE_MODE) -> String:
	var failure_message := "Expecting:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST else "Expecting SAME:"
	var error := "%s\n %s\n do not contains\n %s" % [
					_error(failure_message), _colored_value(current), _colored_value(expected)]
	if not is_empty(found):
		error += "\n but found elements:\n %s" % _colored_value(found)
	return error


# - DictionaryAssert specific messages ----------------------------------------------
static func error_contains_keys(current :Array, expected :Array, keys_not_found :Array, compare_mode :GdObjects.COMPARE_MODE) -> String:
	var failure := (
		"Expecting contains keys:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
		else "Expecting contains SAME keys:"
	)
	return "%s\n %s\n to contains:\n %s\n but can't find key's:\n %s" % [
			_error(failure), _colored_value(current), _colored_value(expected), _colored_value(keys_not_found)]


static func error_not_contains_keys(current :Array, expected :Array, keys_not_found :Array, compare_mode :GdObjects.COMPARE_MODE) -> String:
	var failure := (
		"Expecting NOT contains keys:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
		else "Expecting NOT contains SAME keys"
	)
	return "%s\n %s\n do not contains:\n %s\n but contains key's:\n %s" % [
			_error(failure), _colored_value(current), _colored_value(expected), _colored_value(keys_not_found)]


static func error_contains_key_value(key :Variant, value :Variant, current_value :Variant, compare_mode :GdObjects.COMPARE_MODE) -> String:
	var failure := (
		"Expecting contains key and value:" if compare_mode == GdObjects.COMPARE_MODE.PARAMETER_DEEP_TEST
		else "Expecting contains SAME key and value:"
	)
	return "%s\n %s : %s\n but contains\n %s : %s" % [
			_error(failure), _colored_value(key), _colored_value(value), _colored_value(key), _colored_value(current_value)]


# - ResultAssert specific errors ----------------------------------------------------
static func error_result_is_empty(current :GdUnitResult) -> String:
	return _result_error_message(current, GdUnitResult.EMPTY)


static func error_result_is_success(current :GdUnitResult) -> String:
	return _result_error_message(current, GdUnitResult.SUCCESS)


static func error_result_is_warning(current :GdUnitResult) -> String:
	return _result_error_message(current, GdUnitResult.WARN)


static func error_result_is_error(current :GdUnitResult) -> String:
	return _result_error_message(current, GdUnitResult.ERROR)


static func error_result_has_message(current :String, expected :String) -> String:
	return "%s\n %s\n but was\n %s." % [_error("Expecting:"), _colored_value(expected), _colored_value(current)]


static func error_result_has_message_on_success(expected :String) -> String:
	return "%s\n %s\n but the GdUnitResult is a success." % [_error("Expecting:"), _colored_value(expected)]


static func error_result_is_value(current :Variant, expected :Variant) -> String:
	return "%s\n %s\n but was\n %s." % [_error("Expecting to contain same value:"), _colored_value(expected), _colored_value(current)]


static func _result_error_message(current :GdUnitResult, expected_type :int) -> String:
	if current == null:
		return _error("Expecting the result must be a %s but was <null>." % result_type(expected_type))
	if current.is_success():
		return _error("Expecting the result must be a %s but was SUCCESS." % result_type(expected_type))
	var error := "Expecting the result must be a %s but was %s:" % [result_type(expected_type), result_type(current._state)]
	return "%s\n %s" % [_error(error), _colored_value(result_message(current))]


static func error_interrupted(func_name :String, expected :Variant, elapsed :String) -> String:
	func_name = humanized(func_name)
	if expected == null:
		return "%s %s but timed out after %s" % [_error("Expected:"), func_name, elapsed]
	return "%s %s %s but timed out after %s" % [_error("Expected:"), func_name, _colored_value(expected), elapsed]


static func error_wait_signal(signal_name :String, args :Array, elapsed :String) -> String:
	if args.is_empty():
		return "%s %s but timed out after %s" % [
				_error("Expecting emit signal:"), _colored_value(signal_name + "()"), elapsed]
	return "%s %s but timed out after %s" % [
			_error("Expecting emit signal:"), _colored_value(signal_name + "(" + str(args) + ")"), elapsed]


static func error_signal_emitted(signal_name :String, args :Array, elapsed :String) -> String:
	if args.is_empty():
		return "%s %s but is emitted after %s" % [
				_error("Expecting do not emit signal:"), _colored_value(signal_name + "()"), elapsed]
	return "%s %s but is emitted after %s" % [
			_error("Expecting do not emit signal:"), _colored_value(signal_name + "(" + str(args) + ")"), elapsed]


static func error_await_signal_on_invalid_instance(source :Variant, signal_name :String, args :Array) -> String:
	return "%s\n await_signal_on(%s, %s, %s)" % [
			_error("Invalid source! Can't await on signal:"), _colored_value(source), signal_name, args]


static func result_type(type :int) -> String:
	match type:
		GdUnitResult.SUCCESS: return "SUCCESS"
		GdUnitResult.WARN: return "WARNING"
		GdUnitResult.ERROR: return "ERROR"
		GdUnitResult.EMPTY: return "EMPTY"
	return "UNKNOWN"


static func result_message(result :GdUnitResult) -> String:
	match result._state:
		GdUnitResult.SUCCESS: return ""
		GdUnitResult.WARN: return result.warn_message()
		GdUnitResult.ERROR: return result.error_message()
		GdUnitResult.EMPTY: return ""
	return "UNKNOWN"
# -----------------------------------------------------------------------------------

# - Spy|Mock specific errors ----------------------------------------------------
static func error_no_more_interactions(summary :Dictionary) -> String:
	var interactions := PackedStringArray()
	for args :Array in summary.keys():
		var times :int = summary[args]
		@warning_ignore("return_value_discarded")
		interactions.append(_format_arguments(args, times))
	return "%s\n%s\n%s" % [_error("Expecting no more interactions!"), _error("But found interactions on:"), "\n".join(interactions)]


static func error_validate_interactions(current_interactions: Dictionary, expected_interactions: Dictionary) -> String:
	var collected_interactions := PackedStringArray()
	for args: Array in current_interactions.keys():
		var times: int = current_interactions[args]
		@warning_ignore("return_value_discarded")
		collected_interactions.append(_format_arguments(args, times))

	var arguments: Array = expected_interactions.keys()[0]
	var interactions: int = expected_interactions.values()[0]
	var expected_interaction := _format_arguments(arguments, interactions)
	return "%s\n%s\n%s\n%s" % [
			_error("Expecting interaction on:"), expected_interaction, _error("But found interactions on:"), "\n".join(collected_interactions)]


static func _format_arguments(args :Array, times :int) -> String:
	var fname :String = args[0]
	var fargs := args.slice(1) as Array
	var typed_args := _to_typed_args(fargs)
	var fsignature := _colored_value("%s(%s)" % [fname, ", ".join(typed_args)])
	return "	%s	%d time's" % [fsignature, times]


static func _to_typed_args(args :Array) -> PackedStringArray:
	var typed := PackedStringArray()
	for arg :Variant in args:
		@warning_ignore("return_value_discarded")
		typed.append(_format_arg(arg) + " :" + GdObjects.type_as_string(typeof(arg)))
	return typed


static func _format_arg(arg :Variant) -> String:
	if arg is InputEvent:
		var ie: InputEvent = arg
		return input_event_as_text(ie)
	return str(arg)


static func _find_first_diff(left :Array, right :Array) -> String:
	for index in left.size():
		var l :Variant = left[index]
		var r :Variant = "<no entry>" if index >= right.size() else right[index]
		if not GdObjects.equals(l, r):
			return "at position %s\n '%s' vs '%s'" % [_colored_value(index), _typed_value(l), _typed_value(r)]
	return ""


static func error_has_size(current :Variant, expected: int) -> String:
	@warning_ignore("unsafe_method_access")
	var current_size :Variant = null if current == null else current.size()
	return "%s\n %s\n but was\n %s" % [_error("Expecting size:"), _colored_value(expected), _colored_value(current_size)]


static func error_contains_exactly(current: Array, expected: Array) -> String:
	return "%s\n %s\n but was\n %s" % [_error("Expecting exactly equal:"), _colored_value(expected), _colored_value(current)]


static func format_chars(characters: PackedInt32Array, type: Color) -> PackedInt32Array:
	if characters.size() == 0:# or characters[0] == 10:
		return characters

	# Replace each control character with its readable form
	var formatted_text := characters.to_byte_array().get_string_from_utf32()
	for control_char: String in CONTROL_CHARS:
		var replace_text: String = CONTROL_CHARS[control_char]
		formatted_text = formatted_text.replace(control_char, replace_text)

	# Handle special ASCII control characters (0x00-0x1F, 0x7F)
	var ascii_text := ""
	for i in formatted_text.length():
		var character := formatted_text[i]
		var code := character.unicode_at(0)
		if code < 0x20 and not CONTROL_CHARS.has(character):  # Control characters not handled above
			ascii_text += "<0x%02X>" % code
		elif code == 0x7F:  # DEL character
			ascii_text += "<DEL>"
		else:
			ascii_text += character

	var message := "[bgcolor=#%s][color=white]%s[/color][/bgcolor]" % [
		type.to_html(),
		ascii_text
	]

	var result := PackedInt32Array()
	result.append_array(message.to_utf32_buffer().to_int32_array())
	return result


static func format_invalid(value :String) -> String:
	return "[bgcolor=#%s][color=with]%s[/color][/bgcolor]" % [SUB_COLOR.to_html(), value]


static func humanized(value :String) -> String:
	return value.replace("_", " ")


static func build_failure_message(failure :String, additional_failure_message: String, custom_failure_message: String) -> String:
	var message := failure if custom_failure_message.is_empty() else custom_failure_message
	if additional_failure_message.is_empty():
		return message
	return """
		%s
		[color=LIME_GREEN][b]Additional info:[/b][/color]
		 %s""".dedent().trim_prefix("\n") % [message, additional_failure_message]


static func is_empty(value: Variant) -> bool:
	var arry_value: Array = value
	return arry_value != null and arry_value.is_empty()
