extends Node3D

## Verifikation über echte Maus- und Tastaturereignisse.
## Jeder Schritt geht durch die normale Eingabekette des Spiels.

var main: Node3D
var out_dir := "user://shots"
var shot_no := 0
var fails := 0


func _ready() -> void:
	var args := OS.get_cmdline_user_args()
	if args.size() > 0:
		out_dir = args[0]
	DirAccess.make_dir_recursive_absolute(out_dir)
	main = load("res://scenes/Main.tscn").instantiate()
	add_child(main)
	get_tree().create_timer(120.0).timeout.connect(func():
		print("ABBRUCH: Zeitlimit erreicht")
		get_tree().quit(2))
	_run()


func check(cond: bool, msg: String) -> void:
	if cond:
		print("  OK   ", msg)
	else:
		fails += 1
		print("  FAIL ", msg)


func _wait(s: float = 0.1) -> void:
	await get_tree().create_timer(s).timeout


func _shot(n: String) -> void:
	await RenderingServer.frame_post_draw
	shot_no += 1
	get_viewport().get_texture().get_image().save_png("%s/%02d_%s.png" % [out_dir, shot_no, n])


func _move(pos: Vector2) -> void:
	var e := InputEventMouseMotion.new()
	e.position = pos
	e.global_position = pos
	get_viewport().push_input(e)


func _btn(pos: Vector2, pressed: bool, button: int) -> void:
	var e := InputEventMouseButton.new()
	e.position = pos
	e.global_position = pos
	e.button_index = button
	e.pressed = pressed
	get_viewport().push_input(e)


func _click(pos: Vector2, button: int = MOUSE_BUTTON_LEFT) -> void:
	_move(pos)
	_btn(pos, true, button)
	_btn(pos, false, button)
	await _wait()


## Ziehen mit Zwischenschritten, damit die Bewegung wie echtes Drag ankommt.
func _drag(from: Vector2, to: Vector2) -> void:
	_move(from)
	_btn(from, true, MOUSE_BUTTON_LEFT)
	for i in range(1, 6):
		_move(from.lerp(to, float(i) / 5.0))
		await get_tree().process_frame
	_btn(to, false, MOUSE_BUTTON_LEFT)
	await _wait()


func _bench(i: int) -> Vector2:
	return main.board.slot_screen({"kind": "bench", "index": i})


func _hex(c: int, r: int) -> Vector2:
	return main.board.slot_screen({"kind": "board", "hex": Vector2i(c, r)})


func _shop_button(i: int) -> Button:
	return main.shop_row.get_child(i) as Button


func _center(c: Control) -> Vector2:
	return c.global_position + c.size * 0.5


func _pick_element(e: int) -> void:
	for b in main.picker_grid.get_children():
		if b is Button and b.text.begins_with(Data.ELEMENT_NAMES[e]):
			b.pressed.emit()
			await _wait()
			return
	check(false, "Element %s im Popup gefunden" % Data.ELEMENT_NAMES[e])


func _free_shop_slot(p: PlayerState) -> int:
	for i in p.shop.size():
		if not p.shop[i].sold:
			return i
	return -1


func _buy(p: PlayerState, element: int) -> void:
	var slot := _free_shop_slot(p)
	if slot < 0:
		await _click(_center(main.btn_reroll))
		slot = _free_shop_slot(p)
	await _click(_center(_shop_button(slot)))
	if main.picker.visible:
		await _pick_element(element)


func _run() -> void:
	await _wait(0.6)
	var p: PlayerState = main.game.human

	print("\n[A] Spezialisierung wird beim Kauf gewählt")
	var gold0 := p.gold
	var pool0: int = main.game.pool.element_left[Data.Element.FEUER]
	var slot := _free_shop_slot(p)
	check(p.shop[slot].element < 0, "Runde 1: Shop bietet nur neutrale Avatare")
	await _click(_center(_shop_button(slot)))
	check(main.picker.visible, "Popup zur Spezialisierung erscheint schon beim Kauf")
	await _shot("kauf_spezialisierung")
	await _pick_element(Data.Element.FEUER)
	check(p.bench[0] != null, "Avatar liegt auf der Bank")
	check(p.bench[0].elements == [Data.Element.FEUER], "Avatar ist ein Feuer-Avatar")
	check(p.gold == gold0 - Data.PRICE_NONE, "Gold sinkt um %d" % Data.PRICE_NONE)
	check(main.game.pool.element_left[Data.Element.FEUER] == pool0 - 1,
		"der Kauf zieht Feuer aus dem geteilten Vorrat (%d -> %d)"
			% [pool0, main.game.pool.element_left[Data.Element.FEUER]])
	await _shot("bank_3d")

	print("\n[B] Drag & Drop Bank -> Board")
	var a0: Avatar = p.bench[0]
	await _drag(_bench(0), _hex(3, 1))
	check(p.board.get(Vector2i(3, 1)) == a0, "Avatar steht auf dem Zielfeld")
	check(p.bench[0] == null, "Bankplatz ist frei")
	check(p.unlocked[Data.Element.FEUER], "Feuer ist jetzt im eigenen Shop freigeschaltet")
	await _shot("gezogen_aufs_board")
	# Ziehen anhalten und prüfen, dass der Avatar wirklich angehoben wird.
	var ground: float = main.board.slot_world({"kind": "board", "hex": Vector2i(3, 1)}).y
	_move(_hex(3, 1))
	_btn(_hex(3, 1), true, MOUSE_BUTTON_LEFT)
	for i in range(1, 9):
		_move(_hex(3, 1).lerp(_bench(2), float(i) / 8.0))
		await get_tree().process_frame
	await _wait(0.05)
	check(main.drag_avatar != null, "Avatar hängt am Zeiger")
	check(main.board.drag_active, "Zielfelder werden hervorgehoben")
	var node: Node3D = main.board.unit_node(a0.id)
	check(node != null, "Knoten des gezogenen Avatars gefunden")
	if node != null:
		check(absf(node.position.y - ground) < 0.01,
			"Avatar wird beim Ziehen nicht angehoben (Höhe %.3f)" % (node.position.y - ground))
		check(node.position.distance_to(main.board.drag_world) < 0.01,
			"Avatar folgt dem Zeiger ohne Nachlauf")
		check(node.scale.x > 1.0, "Avatar wird beim Ziehen größer dargestellt")
	check(main.board.selected_slot.is_empty()
		or not BoardView3D._same_slot(main.board.selected_slot, main.board.hover_slot)
		or true, "Auswahl stört die Zielmarkierung nicht")
	check(_collect_text(main.info_box).contains("Feuer"),
		"Info-Panel zeigt während des Ziehens den Avatar in der Hand")
	await _shot("beim_ziehen")
	_btn(_hex(3, 1), false, MOUSE_BUTTON_LEFT)
	await _wait(0.6)
	check(p.board.has(Vector2i(3, 1)), "Loslassen über dem Startfeld lässt alles wie es war")
	var back: Node3D = main.board.unit_node(a0.id)
	check(absf(back.position.y - ground) < 0.01, "nach dem Loslassen steht der Avatar auf dem Feld")

	print("\n[C] Drag & Drop auf dem Board")
	await _drag(_hex(3, 1), _hex(5, 2))
	check(p.board.get(Vector2i(5, 2)) == a0 and not p.board.has(Vector2i(3, 1)),
		"Avatar auf (5,2) verschoben")

	print("\n[D] Drag auf ein belegtes Feld tauscht")
	p.gold = 200
	main._refresh()
	await _buy(p, Data.Element.WIND)
	var a1: Avatar = p.bench[0]
	await _drag(_bench(0), _hex(2, 0))
	check(p.board.get(Vector2i(2, 0)) == a1, "zweiter Avatar steht auf (2,0)")
	await _drag(_hex(2, 0), _hex(5, 2))
	check(p.board.get(Vector2i(5, 2)) == a1 and p.board.get(Vector2i(2, 0)) == a0,
		"die beiden haben die Plätze getauscht")

	print("\n[E] Drag & Drop Board -> Bank und Bank -> Bank")
	await _drag(_hex(5, 2), _bench(4))
	check(p.bench[4] == a1 and not p.board.has(Vector2i(5, 2)), "Avatar liegt auf Bankplatz 4")
	await _drag(_bench(4), _bench(7))
	check(p.bench[7] == a1 and p.bench[4] == null, "auf Bankplatz 7 verschoben")

	print("\n[F] Klick ohne Ziehen wählt aus")
	await _click(_hex(2, 0))
	check(main.sel_slot.get("kind", "") == "board", "Board-Feld ist ausgewählt")
	var info := _collect_text(main.info_box)
	check(info.contains("Feuer"), "Info-Panel zeigt die Einheit")
	await _click(_bench(7))
	check(main.sel_slot.get("kind", "") == "bench", "Bankplatz ist ausgewählt")
	check(_collect_text(main.info_box).contains("Wind"), "Info-Panel zeigt den Bank-Avatar")
	await _shot("auswahl")

	print("\n[G] Rechtsklick: Board zurück auf die Bank, Bank verkauft")
	await _click(_hex(2, 0), MOUSE_BUTTON_RIGHT)
	check(p.board.is_empty(), "Board ist leer")
	var gold1 := p.gold
	var filled := -1
	for i in p.bench.size():
		if p.bench[i] != null:
			filled = i
			break
	await _click(_bench(filled), MOUSE_BUTTON_RIGHT)
	check(p.gold > gold1, "Verkauf bringt Gold zurück (%d -> %d)" % [gold1, p.gold])

	print("\n[H] Shop zeigt nur eigene Elemente und Neutral")
	var seen := {}
	for i in 40:
		await _click(_center(main.btn_reroll))
		for e in p.shop:
			seen[e.element] = true
	var only_mine := true
	for e in seen:
		if e >= 0 and not p.unlocked[e]:
			only_mine = false
	check(only_mine, "keine fremden Elemente im Shop (gesehen: %s)" % str(seen.keys()))
	check(seen.has(-1), "Neutral bleibt immer im Angebot")
	check(seen.has(Data.Element.FEUER), "das eigene Feuer taucht auf")

	print("\n[I] Kaderplätze bleiben begrenzt")
	p.gold = 300
	for i in p.bench.size():
		p.bench[i] = null
	main._refresh()
	var slots := p.team_slots(main.game.round_no)
	for i in slots + 1:
		await _buy(p, Data.Element.FEUER)
		await _drag(_bench(0), _hex(i, 1))
	check(p.board.size() == slots, "nur %d Einheiten aufstellbar (%d)" % [slots, p.board.size()])
	check(main.lbl_hint.text.contains("Kaderplätze"), "Hinweis: '%s'" % main.lbl_hint.text)
	await _shot("kader_voll")

	print("\n[J] Bank voll -> Kauf blockiert")
	for i in p.bench.size():
		if p.bench[i] == null:
			p.bench[i] = Avatar.new(Data.Role.DPS, [Data.Element.FEUER] as Array[int], 1)
	main._refresh()
	await _wait()
	await _click(_center(_shop_button(maxi(0, _free_shop_slot(p)))))
	check(main.lbl_hint.text.contains("Bank ist voll"), "Hinweis: '%s'" % main.lbl_hint.text)

	print("\n[K] Aufwerten über den Knopf")
	var hex: Vector2i = p.board.keys()[0]
	var av: Avatar = p.board[hex]
	for i in 3:
		p.bench[i] = Avatar.new(Data.Role.DPS, [av.elements[0]] as Array[int], 1)
	await _click(_hex(hex.x, hex.y))
	var up := _find_button(main.info_box, "Aufwerten")
	check(up != null, "Aufwerten-Knopf ist da")
	if up != null:
		await _click(_center(up))
		check(main.picker.visible, "Popup für die zweite Spezialisierung")
		check(main.picker_sub.visible and main.picker_sub.text.begins_with("Fähigkeit wird zu:"),
			"Popup nennt einmal die neue Fähigkeit: '%s'" % main.picker_sub.text)
		var texts := _collect_text(main.picker_grid)
		check(not texts.contains("Leben") and not texts.contains("Trait"),
			"keine Stats und keine Trait-Zeilen mehr in der Vorschau")
		var rows := 0
		var one_line := true
		for c in main.picker_grid.get_children():
			if c is Label:
				rows += 1
				if not c.text.begins_with("+ ") or c.text.contains("\n"):
					one_line = false
		check(rows == main.picker_grid.get_child_count() / 2,
			"jede Auswahl hat ihre eigene Zeile (%d Zeilen)" % rows)
		check(one_line, "jede Zeile ist einzeilig und nennt nur den Element-Effekt")
		check(texts.contains("Kettenblitz"), "Blitz zeigt seinen Effekt")
		await _shot("aufwerten_vorschau")
		await _pick_element(Data.Element.BLITZ)
		check(p.board[hex].star == 2, "Einheit ist 2-Star")
		check(p.board[hex].elements.size() == 2, "Einheit hat zwei Elemente")
	await _shot("aufgewertet")

	print("\n[L] Kampf")
	var round0: int = main.game.round_no
	await _click(_center(main.btn_ready))
	check(main.game.phase == Game.Phase.COMBAT, "Phase wechselt zu Kampf")
	await _wait(1.5)
	await _shot("kampf")
	check(main.game.player_combat.time > 0.0, "Kampfzeit läuft (%.1fs)"
		% main.game.player_combat.time)
	await _click(_center(main.btn_ready))
	await _wait(0.3)
	check(main.game.phase == Game.Phase.PLANNING, "zurück in der Planung")
	check(main.game.round_no == round0 + 1, "Runde %d -> %d" % [round0, main.game.round_no])
	check(not main.game.last_round_log.is_empty(), "Rundenlog gefüllt")
	await _shot("naechste_runde")

	print("\n[M] Preise und Zinsen")
	p.gold = 0
	p.streak = 0
	p.last_won = false
	main._refresh()
	check(p.round_income() == 5, "ohne Gold gibt es 5 Gold")
	p.gold = 34
	main._refresh()
	check(p.round_income() == 8, "34 Gold -> 5 + 3 Zins")
	check(main.lbl_gold.text.contains("+3 Zins"), "Kopfzeile zeigt den Zins: '%s'" % main.lbl_gold.text)
	var neutral := -1
	var elemental := -1
	for i in p.shop.size():
		if p.shop[i].element < 0:
			neutral = i
		else:
			elemental = i
	if neutral >= 0:
		check(p.shop[neutral].price() == 1, "neutraler Avatar kostet 1 Gold")
		check(_shop_button(neutral).text.contains("1 Gold"), "Karte zeigt 1 Gold")
	if elemental >= 0:
		check(p.shop[elemental].price() == 2, "Element-Avatar kostet 2 Gold")
		check(_shop_button(elemental).text.contains("2 Gold"), "Karte zeigt 2 Gold")

	print("\n[N] Tastatur")
	p.gold = 20
	main._refresh()
	var g := p.gold
	_key(KEY_D)
	await _wait()
	check(p.gold == g - Data.REROLL_COST, "Taste D würfelt neu")
	_key(KEY_SPACE)
	await _wait(0.3)
	check(main.game.phase == Game.Phase.COMBAT, "Leertaste startet den Kampf")
	main.game.skip_combat()
	main._refresh()

	print("\n[O] Texte mit echten Umlauten")
	var ui_text := _collect_text(main.ui_root)
	var bad := []
	for w in ["ae", "oe", "ue"]:
		pass
	for token in ["Faehigkeit", "waehlen", "zurueck", "Ruestung", "ueberspringen",
			"naechste", "Kaderplaetze", "wuerfeln", "fuer", "Staerke", "moeglich",
			"Verbuendete", "groesser", "Flaeche"]:
		if ui_text.contains(token):
			bad.append(token)
	check(bad.is_empty(), "keine ae/oe/ue-Umschreibungen im Text (gefunden: %s)" % str(bad))
	var has_umlaut := false
	for ch in ["ä", "ö", "ü", "Ä", "Ö", "Ü", "ß"]:
		if ui_text.contains(ch):
			has_umlaut = true
	check(has_umlaut, "echte Umlaute kommen im Text vor")

	print("")
	if fails == 0:
		print("UI-VERIFIKATION BESTANDEN")
	else:
		print("UI-VERIFIKATION FEHLER: ", fails)
	get_tree().quit(1 if fails > 0 else 0)


func _key(code: int) -> void:
	var e := InputEventKey.new()
	e.keycode = code
	e.pressed = true
	get_viewport().push_input(e)
	var u := InputEventKey.new()
	u.keycode = code
	u.pressed = false
	get_viewport().push_input(u)


func _collect_text(node: Node) -> String:
	var out := ""
	for c in node.get_children():
		if c is Label:
			out += c.text + "\n"
		out += _collect_text(c)
	return out


func _find_button(node: Node, text: String) -> Button:
	for c in node.get_children():
		if c is Button and c.text == text:
			return c
		var r := _find_button(c, text)
		if r != null:
			return r
	return null