extends SceneTree

var received_invites: Array = []


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


func _run() -> void:
	var nakama = root.get_node("Nakama")
	var host := OS.get_environment("VOID_BASTION_TEST_HOST")
	var scheme := OS.get_environment("VOID_BASTION_TEST_SCHEME")
	var port_text := OS.get_environment("VOID_BASTION_TEST_PORT")
	if host.is_empty():
		host = "192.168.178.20"
	if scheme.is_empty():
		scheme = "http"
	var port := int(port_text) if not port_text.is_empty() else 7350
	var client_a: NakamaClient = nakama.create_client("voidbastion-public-v1", host, port, scheme, 5, NakamaLogger.LOG_LEVEL.ERROR)
	var client_b: NakamaClient = nakama.create_client("voidbastion-public-v1", host, port, scheme, 5, NakamaLogger.LOG_LEVEL.ERROR)
	var suffix := str(Time.get_ticks_usec())
	var session_a: NakamaSession = await client_a.authenticate_device_async("social_test_a_" + suffix, "social_a_" + suffix, true)
	var session_b: NakamaSession = await client_b.authenticate_device_async("social_test_b_" + suffix, "social_b_" + suffix, true)
	assert(not session_a.is_exception() and not session_b.is_exception(), "Beide Testkonten müssen sich anmelden können.")
	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())
	assert(not (await socket_b.connect_async(session_b, true, 5)).is_exception())
	socket_b.received_notification.connect(func(note):
		if int(note.code) == 101:
			received_invites.append(JSON.parse_string(note.content)))
	var requested = await client_a.add_friends_async(session_a, null, PackedStringArray([session_b.username]))
	assert(not requested.is_exception(), "Eine Freundschaftsanfrage muss gesendet werden können.")
	var accepted = await client_b.add_friends_async(session_b, PackedStringArray([session_a.user_id]))
	assert(not accepted.is_exception(), "Die Anfrage muss angenommen werden 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 gegenseitige Freundschaft muss auf dem Server gespeichert sein.")
	var followed = await socket_a.follow_users_async(PackedStringArray([session_b.user_id]), PackedStringArray())
	assert(not followed.is_exception(), "Der Freundesstatus muss abonnierbar sein.")
	assert(not (await socket_b.update_status_async("playing")).is_exception(), "Der Im-Spiel-Status muss gesetzt werden können.")
	var created = await client_a.rpc_async(session_a, "create_private_room", JSON.stringify({"difficulty": 1}))
	assert(not created.is_exception(), "Ein privater Raum muss erstellbar sein.")
	var room: Dictionary = JSON.parse_string(created.payload)
	var code := String(room.get("room_code", ""))
	assert(code.length() == 6)
	var joined = await socket_a.join_match_async(String(room.get("match_id", "")))
	assert(not joined.is_exception(), "Der Gastgeber muss den privaten Raum betreten können.")
	var invited = await client_a.rpc_async(session_a, "invite_friend", JSON.stringify({"friend_id": session_b.user_id, "room_code": code}))
	assert(not invited.is_exception() and bool(JSON.parse_string(invited.payload).get("accepted", false)),
		"Der Gastgeber muss einen bestätigten Freund einladen können.")
	for attempt in 40:
		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", "")) == code,
		"Die Echtzeit-Einladung muss den Raumcode enthalten.")
	var unauthorized = await client_b.rpc_async(session_b, "invite_friend", JSON.stringify({"friend_id": session_a.user_id, "room_code": code}))
	assert(not unauthorized.is_exception() and not bool(JSON.parse_string(unauthorized.payload).get("accepted", true)),
		"Ein Mitspieler ohne Gastgeberrolle darf keine Einladung versenden.")
	socket_a.close()
	socket_b.close()
	var deleted_a = await client_a.rpc_async(session_a, "delete_account", "{}")
	var deleted_b = await client_b.rpc_async(session_b, "delete_account", "{}")
	assert(not deleted_a.is_exception() and not deleted_b.is_exception(), "Die Testkonten müssen entfernt werden können.")
	print("VOID_BASTION_SOCIAL_INTEGRATION_OK")
	quit()