extends SceneTree

var matched_a = null
var matched_b = null
var snapshot_a: Dictionary = {}
var snapshot_b: Dictionary = {}


func _initialize() -> void:
	call_deferred("_run")


func _run() -> void:
	var nakama = root.get_node("Nakama")
	var test_host := OS.get_environment("VOID_BASTION_TEST_HOST")
	var test_scheme := OS.get_environment("VOID_BASTION_TEST_SCHEME")
	var test_port_text := OS.get_environment("VOID_BASTION_TEST_PORT")
	if test_host.is_empty():
		test_host = "192.168.178.20"
	if test_scheme.is_empty():
		test_scheme = "http"
	var test_port := int(test_port_text) if not test_port_text.is_empty() else 7350
	var client_a: NakamaClient = nakama.create_client("voidbastion-public-v1", test_host, test_port, test_scheme, 5, NakamaLogger.LOG_LEVEL.ERROR)
	var client_b: NakamaClient = nakama.create_client("voidbastion-public-v1", test_host, test_port, test_scheme, 5, NakamaLogger.LOG_LEVEL.ERROR)
	var suffix := str(Time.get_ticks_usec())
	var session_a: NakamaSession = await client_a.authenticate_device_async("voidbastion_godot_test_a_" + suffix, "godot_a_" + suffix, true)
	var session_b: NakamaSession = await client_b.authenticate_device_async("voidbastion_godot_test_b_" + suffix, "godot_b_" + suffix, true)
	assert(not session_a.is_exception() and session_a.is_valid(), "Godot-Client A muss ein Gastkonto anmelden können: %s" % session_a)
	assert(not session_b.is_exception() and session_b.is_valid(), "Godot-Client B muss ein Gastkonto anmelden können: %s" % session_b)

	var info = await client_a.rpc_async(session_a, "server_info", "{}")
	assert(not info.is_exception(), "Die Godot-Anbindung muss Server-RPCs erreichen.")
	var info_data = JSON.parse_string(info.payload)
	assert(info_data is Dictionary and info_data.get("status") == "online", "Der Server muss seinen Onlinestatus melden.")
	assert(info_data.get("version") == "0.25", "Der Server muss die aktuelle Runtime 0.25 geladen haben: %s" % info_data)

	var deletion_client: NakamaClient = nakama.create_client("voidbastion-public-v1", test_host, test_port, test_scheme, 5, NakamaLogger.LOG_LEVEL.ERROR)
	var deletion_session: NakamaSession = await deletion_client.authenticate_device_async("voidbastion_delete_test_" + suffix, "delete_test_" + suffix, true)
	assert(not deletion_session.is_exception() and deletion_session.is_valid(), "Ein Wegwerf-Testkonto muss angelegt werden können.")
	var renamed = await deletion_client.rpc_async(deletion_session, "update_display_name", JSON.stringify({"display_name": "Testpilot Ägir"}))
	assert(not renamed.is_exception(), "Ein gültiger Spielername muss serverseitig gespeichert werden können.")
	var renamed_data = JSON.parse_string(renamed.payload)
	assert(renamed_data is Dictionary and bool(renamed_data.get("accepted", false)), "Der Server muss die Namensänderung bestätigen.")
	var invalid_name = await deletion_client.rpc_async(deletion_session, "update_display_name", JSON.stringify({"display_name": "ADMIN"}))
	assert(not invalid_name.is_exception(), "Ein ungültiger Spielername muss kontrolliert abgelehnt werden.")
	var invalid_name_data = JSON.parse_string(invalid_name.payload)
	assert(invalid_name_data is Dictionary and not bool(invalid_name_data.get("accepted", true)), "Reservierte Spielernamen dürfen nicht angenommen werden.")
	var deleted = await deletion_client.rpc_async(deletion_session, "delete_account", "{}")
	assert(not deleted.is_exception(), "Das Wegwerf-Testkonto muss im Spiel löschbar sein.")

	var public_leaderboard_name := "Rangpilot %s" % suffix.right(6)
	var renamed_a = await client_a.rpc_async(session_a, "update_display_name", JSON.stringify({"display_name": public_leaderboard_name}))
	assert(not renamed_a.is_exception() and bool(JSON.parse_string(renamed_a.payload).get("accepted", false)), "Der Ranglistenpilot muss einen öffentlichen Namen setzen können.")
	var run_payload := JSON.stringify({"map": 1, "difficulty": 1, "mode": "mission", "wave": 4, "score": 4700, "client_version": "0.25-integration"})
	var submitted = await client_a.rpc_async(session_a, "submit_run", run_payload)
	assert(not submitted.is_exception(), "Ein plausibles Ergebnis muss serverseitig angenommen werden.")
	var records = await client_a.list_leaderboard_records_async(session_a, "mission_map1_difficulty1", [session_a.user_id], null, 10)
	assert(not records.is_exception() and (records.records.size() >= 1 or records.owner_records.size() >= 1), "Das Ergebnis muss über das Godot-SDK aus der Rangliste lesbar sein.")
	var own_record = null
	for record in records.owner_records:
		if record.owner_id == session_a.user_id:
			own_record = record
			break
	assert(own_record != null and own_record.username == public_leaderboard_name, "Die Rangliste muss den öffentlichen Spielernamen statt der technischen Gast-ID zeigen.")

	var socket_a: NakamaSocket = nakama.create_socket_from(client_a)
	var socket_b: NakamaSocket = nakama.create_socket_from(client_b)
	assert(not (await socket_a.connect_async(session_a, true, 5)).is_exception(), "Spieler A benötigt eine Echtzeitverbindung.")
	assert(not (await socket_b.connect_async(session_b, true, 5)).is_exception(), "Spieler B benötigt eine Echtzeitverbindung.")
	var friend_request = await client_a.add_friends_async(session_a, null, PackedStringArray([session_b.username]))
	assert(not friend_request.is_exception(), "Spieler A muss eine Freundschaftsanfrage senden können.")
	var friend_accept = await client_b.add_friends_async(session_b, PackedStringArray([session_a.user_id]))
	assert(not friend_accept.is_exception(), "Spieler B muss die Freundschaftsanfrage bestätigen können.")
	var friend_list = await client_a.list_friends_async(session_a, 0, 100)
	assert(not friend_list.is_exception() and friend_list.friends.size() == 1 and friend_list.friends[0].user.id == session_b.user_id,
		"Die bestätigte Freundschaft muss beim Gastgeber sichtbar sein.")
	var received_invites: Array = []
	socket_b.received_notification.connect(func(note):
		if int(note.code) == 101:
			received_invites.append(JSON.parse_string(note.content)))
	socket_a.received_matchmaker_matched.connect(func(value): matched_a = value)
	socket_b.received_matchmaker_matched.connect(func(value): matched_b = value)
	socket_a.received_match_state.connect(func(value): _capture_snapshot(value, true))
	socket_b.received_match_state.connect(func(value): _capture_snapshot(value, false))
	var props := {"game": "void_bastion", "mode": "quick"}
	var production_query := "+properties.game:void_bastion +properties.mode:quick +properties.difficulty:1"
	var ticket_a = await socket_a.add_matchmaker_async(production_query, 2, 2, props, {"difficulty": 1.0})
	var ticket_b = await socket_b.add_matchmaker_async(production_query, 2, 2, props, {"difficulty": 1.0})
	assert(not ticket_a.is_exception() and not ticket_b.is_exception(), "Beide Spieler müssen die Mitspielersuche starten können.")
	for attempt in 300:
		if matched_a != null and matched_b != null:
			break
		await create_timer(0.05).timeout
	assert(matched_a != null and matched_b != null, "Der Server muss zwei passende Spieler vermitteln.")
	var match_a = await socket_a.join_matched_async(matched_a)
	var match_b = await socket_b.join_matched_async(matched_b)
	assert(not match_a.is_exception() and not match_b.is_exception(), "Beide Spieler müssen der autoritativen Koop-Partie beitreten können.")
	assert(match_a.match_id == match_b.match_id, "Beide Spieler müssen dieselbe Koop-Partie erhalten.")
	await create_timer(0.2).timeout
	assert(not bool(snapshot_a.get("started", false)), "Die Partie darf vor der Bereitschaft beider Spieler nicht starten.")
	await socket_a.send_match_state_async(match_a.match_id, 14, JSON.stringify({"ready": true, "name": "TESTPILOT ALPHA"}))
	await socket_b.send_match_state_async(match_b.match_id, 14, JSON.stringify({"ready": true, "name": "TESTPILOT BETA"}))
	for attempt in 100:
		if bool(snapshot_a.get("started", false)) and bool(snapshot_b.get("started", false)):
			break
		await create_timer(0.05).timeout
	assert(bool(snapshot_a.get("started", false)) and bool(snapshot_b.get("started", false)), "Beide Clients müssen den gestarteten Serverzustand empfangen.")
	var slot_a := int((snapshot_a.get("slots", {}) as Dictionary).get(session_a.user_id, -1))
	var slot_b := int((snapshot_b.get("slots", {}) as Dictionary).get(session_b.user_id, -1))
	assert(slot_a != slot_b and slot_a in [0, 1] and slot_b in [0, 1], "Der Server muss beiden Spielern unterschiedliche Seiten zuweisen.")
	var build_a := {"tower_type": 0, "x": 200.0 if slot_a == 0 else 2760.0, "y": 200.0}
	var build_b := {"tower_type": 1, "x": 200.0 if slot_b == 0 else 2760.0, "y": 200.0}
	await socket_a.send_match_state_async(match_a.match_id, 10, JSON.stringify(build_a))
	await socket_b.send_match_state_async(match_b.match_id, 10, JSON.stringify(build_b))
	await socket_a.send_match_state_async(match_a.match_id, 13, "{}")
	for attempt in 120:
		if int(snapshot_a.get("wave", 0)) == 1 and (snapshot_a.get("towers", []) as Array).size() == 2 and int(snapshot_b.get("wave", 0)) == 1:
			break
		await create_timer(0.05).timeout
	assert(int(snapshot_a.get("wave", 0)) == 1, "Der Server muss die gemeinsame Welle starten.")
	assert((snapshot_a.get("towers", []) as Array).size() == 2, "Beide autorisierten Bauaufträge müssen serverseitig sichtbar sein.")
	assert(JSON.stringify(snapshot_a.get("towers", [])) == JSON.stringify(snapshot_b.get("towers", [])), "Beide Clients müssen denselben Turmzustand erhalten.")
	assert(int(snapshot_a.get("reactor_lives", 0)) == int(snapshot_b.get("reactor_lives", -1)), "Beide Clients müssen dieselben gemeinsamen Reaktorleben sehen.")
	assert(not (await socket_a.leave_match_async(match_a.match_id)).is_exception(), "Spieler A muss die schnelle Partie verlassen können.")
	assert(not (await socket_b.leave_match_async(match_b.match_id)).is_exception(), "Spieler B muss die schnelle Partie verlassen können.")
	await create_timer(0.2).timeout
	snapshot_a = {}
	snapshot_b = {}
	var created_room = await client_a.rpc_async(session_a, "create_private_room", JSON.stringify({"difficulty": 2}))
	assert(not created_room.is_exception(), "Spieler A muss einen privaten Raum erstellen können.")
	var created_data = JSON.parse_string(created_room.payload)
	assert(created_data is Dictionary, "Der private Raum muss gültige Daten liefern.")
	var room_code := String(created_data.get("room_code", ""))
	var private_match_id := String(created_data.get("match_id", ""))
	assert(room_code.length() == 6 and not private_match_id.is_empty(), "Der Server muss einen sechsstelligen Raumcode und eine Partie liefern.")
	var private_match_a = await socket_a.join_match_async(private_match_id)
	assert(not private_match_a.is_exception(), "Der Gastgeber muss seinem privaten Raum beitreten können.")
	var invite = await client_a.rpc_async(session_a, "invite_friend", JSON.stringify({"friend_id": session_b.user_id, "room_code": room_code}))
	assert(not invite.is_exception() and bool(JSON.parse_string(invite.payload).get("accepted", false)), "Der Gastgeber muss einen bestätigten Freund einladen können.")
	for attempt in 30:
		if not received_invites.is_empty():
			break
		await create_timer(0.05).timeout
	assert(not received_invites.is_empty() and received_invites[0] is Dictionary and String(received_invites[0].get("room_code", "")) == room_code,
		"Die Einladung muss als Echtzeitbenachrichtigung mit dem richtigen Raumcode ankommen.")
	var found_room = await client_b.rpc_async(session_b, "join_private_room", JSON.stringify({"room_code": room_code.to_lower()}))
	assert(not found_room.is_exception(), "Der Mitspieler muss den Raumcode unabhängig von Groß-/Kleinschreibung finden können.")
	var found_data = JSON.parse_string(found_room.payload)
	assert(found_data is Dictionary and String(found_data.get("match_id", "")) == private_match_id, "Der Raumcode muss genau zur erstellten Partie führen: %s" % found_data)
	var private_match_b = await socket_b.join_match_async(private_match_id)
	assert(not private_match_b.is_exception(), "Der Mitspieler muss dem privaten Raum beitreten können.")
	await create_timer(0.2).timeout
	assert(not bool(snapshot_a.get("started", false)), "Auch private Räume müssen auf die Bereitschaft beider Spieler warten.")
	var lobby_players: Array = snapshot_a.get("players", [])
	assert(lobby_players.size() == 2 and lobby_players[0] is Dictionary and lobby_players[1] is Dictionary, "Die Lobby muss beide Spielerplätze anzeigen.")
	assert(not (await socket_b.leave_match_async(private_match_id)).is_exception(), "Ein Mitspieler muss die Lobby verlassen können.")
	await create_timer(0.2).timeout
	lobby_players = snapshot_a.get("players", [])
	assert(lobby_players.size() == 2 and not bool(lobby_players[1].get("connected", true)), "Die Lobby muss einen getrennten Mitspieler erkennen.")
	private_match_b = await socket_b.join_match_async(private_match_id)
	assert(not private_match_b.is_exception(), "Der reservierte Spieler muss demselben Raum wieder beitreten können.")
	await socket_a.send_match_state_async(private_match_id, 14, JSON.stringify({"ready": true, "name": "TESTPILOT ALPHA"}))
	await socket_b.send_match_state_async(private_match_id, 14, JSON.stringify({"ready": true, "name": "TESTPILOT BETA"}))
	for attempt in 100:
		if bool(snapshot_a.get("started", false)) and bool(snapshot_b.get("started", false)):
			break
		await create_timer(0.05).timeout
	assert(bool(snapshot_a.get("started", false)) and bool(snapshot_b.get("started", false)), "Der private Raum muss mit zwei Spielern die gemeinsame Partie starten.")
	assert(int(snapshot_a.get("difficulty", -1)) == 2 and int(snapshot_b.get("difficulty", -1)) == 2, "Die private Partie muss den Schwierigkeitsgrad des Gastgebers übernehmen.")
	assert(private_match_a.match_id == private_match_b.match_id, "Beide Spieler müssen über den Raumcode dieselbe private Partie erhalten.")
	socket_a.close()
	socket_b.close()
	print("VOID_BASTION_ONLINE_INTEGRATION_OK")
	quit()


func _capture_snapshot(message, client_a: bool) -> void:
	if int(message.op_code) != 1:
		return
	var parsed = JSON.parse_string(message.data)
	if not parsed is Dictionary:
		return
	if client_a:
		snapshot_a = parsed
	else:
		snapshot_b = parsed