extends Control

@onready var lobby_name_txt = $CreateLobbyCont/LobbyNameTxt
@onready var lobby_visibility = $CreateLobbyCont/LobbyVisibilityBtn
@onready var max_members = $CreateLobbyCont/MaxMembersBtn
@onready var lobby_member = preload("res://addons/godot_steam_sync/Lobby/lobby_member.tscn")
@onready var lobby_name_lbl = $LobbyPanel/MarginContainer/LobbyCont/Panel/LobbyNameLbl
@onready var start_btn = $LobbyPanel/MarginContainer/LobbyCont/StartBtn
var im_ready : bool = false
func _ready() -> void:
	Steam.join_requested.connect(_on_lobby_join_requested)
	#Steam.lobby_chat_update.connect(_on_lobby_chat_update)
	Steam.lobby_created.connect(_on_lobby_created)
	#Steam.lobby_data_update.connect(_on_lobby_data_update)
	#Steam.lobby_invite.connect(_on_lobby_invite)
	Steam.lobby_joined.connect(_on_lobby_joined)
	#Steam.lobby_match_list.connect(_on_lobby_match_list)
	#Steam.lobby_message.connect(_on_lobby_message)
	Steam.persona_state_change.connect(_on_persona_change)
	Steam.p2p_session_request.connect(_on_p2p_session_request)
	Steam.p2p_session_connect_fail.connect(_on_p2p_session_connect_fail)


	# Check for command line arguments
	check_command_line()
	
func check_command_line() -> void:
	var these_arguments: Array = OS.get_cmdline_args()

	# There are arguments to process
	if these_arguments.size() > 0:

		# A Steam connection argument exists
		if these_arguments[0] == "+connect_lobby":

			# Lobby invite exists so try to connect to it
			if int(these_arguments[1]) > 0:

				# At this point, you'll probably want to change scenes
				# Something like a loading into lobby screen
				print("Command line lobby ID: %s" % these_arguments[1])
				join_lobby(int(these_arguments[1]))
				
#region JoinLobbyRegion
func join_lobby(this_lobby_id: int) -> void:
	print("Attempting to join lobby %s" % this_lobby_id)

	# Clear any previous lobby members lists, if you were in a previous lobby
	NetworkManager.LOBBY_MEMBERS.clear()

	# Make the lobby join request to Steam
	Steam.joinLobby(this_lobby_id)

func _on_lobby_joined(lobby_id: int, _permissions: int, _locked: bool, response: int):
	# If joining succeed, this will be 1
	if response == 1:
		# Set this lobby ID as your lobby ID
		NetworkManager.LOBBY_ID = lobby_id
		# Print the lobby ID to a label
		lobby_name_lbl.set_text(Steam.getLobbyData(NetworkManager.LOBBY_ID,"name"))
		# Append to output
		print("[STEAM] Joined lobby "+str(NetworkManager.LOBBY_ID)+".\n")
		# Get the lobby members
		get_lobby_members()
		# Make the initial handshake
		make_p2p_handshake()
		change_lobby_ui(true)
		
	# Else it failed for some reason
	else:
		# Get the failure reason
		var FAIL_REASON: String
		match response:
			2:	FAIL_REASON = "This lobby no longer exists."
			3:	FAIL_REASON = "You don't have permission to join this lobby."
			4:	FAIL_REASON = "The lobby is now full."
			5:	FAIL_REASON = "Uh... something unexpected happened!"
			6:	FAIL_REASON = "You are banned from this lobby."
			7:	FAIL_REASON = "You cannot join due to having a limited account."
			8:	FAIL_REASON = "This lobby is locked or disabled."
			9:	FAIL_REASON = "This lobby is community locked."
			10:	FAIL_REASON = "A user in the lobby has blocked you from joining."
			11:	FAIL_REASON = "A user you have blocked is in the lobby."
		$Frame/Main/Displays/Outputs/Output.append_text("[STEAM] Failed joining lobby "+str(lobby_id)+": "+str(FAIL_REASON)+"\n")
		# Reopen the server list
		#_on_Open_Lobby_List_pressed()

func _on_lobby_join_requested(lobby_id: int, friend_id: int):
	# Get the lobby owner's name
	var OWNER_NAME = Steam.getFriendPersonaName(friend_id)
	print("[STEAM] Joining "+str(OWNER_NAME)+"'s lobby...\n")
	# Attempt to join the lobby
	join_lobby(lobby_id)
#endregion

func change_lobby_ui(current : bool):
	if current:
		$CreateLobbyCont.hide()
		$LobbyPanel.show()
		$MembersPnl.show()
	else:
		$CreateLobbyCont.show()
		$LobbyPanel.hide()
		$MembersPnl.hide()
	
#region CreateLobbyRegion
func _on_create_lobby_btn_pressed():
	if NetworkManager.LOBBY_ID == 0:
		Steam.createLobby(lobby_visibility.get_selected_id(), int(max_members.get_item_text(max_members.get_selected_id())))
		
func _on_lobby_created(connect: int, this_lobby_id: int) -> void:
	if connect == 1:
		# Set the lobby ID
		NetworkManager.LOBBY_ID = this_lobby_id
		print("Created a lobby: %s" % NetworkManager.LOBBY_ID )
		# Set this lobby as joinable, just in case, though this should be done by default
		Steam.setLobbyJoinable(NetworkManager.LOBBY_ID, true)
		# Set some lobby data
		Steam.setLobbyData(NetworkManager.LOBBY_ID, "name", lobby_name_txt.text)
		Steam.setLobbyData(NetworkManager.LOBBY_ID, "mode", "Mechatronauts")

		# Allow P2P connections to fallback to being relayed through Steam if needed
		var set_relay: bool = Steam.allowP2PPacketRelay(true)
		
		get_lobby_members()
		change_lobby_ui(true)
#endregion
func get_lobby_members() -> void:
	# Clear your previous lobby list
	NetworkManager.LOBBY_MEMBERS.clear()
	for MEMBER in $MembersPnl/MarginContainer/ScrollContainer/VBoxContainer.get_children():
		MEMBER.hide()
		MEMBER.queue_free()
	# Get the number of members from this lobby from Steam
	var num_of_members: int = Steam.getNumLobbyMembers(NetworkManager.LOBBY_ID)

	# Get the data of these players from Steam
	for this_member in range(0, num_of_members):
		# Get the member's Steam ID
		var member_steam_id: int = Steam.getLobbyMemberByIndex(NetworkManager.LOBBY_ID, this_member)
		
		# Get the member's Steam name
		var member_steam_name: String = Steam.getFriendPersonaName(member_steam_id)

		# Add them to the list
		add_member_to_list(member_steam_id,member_steam_name)
		if NetworkManager.STEAM_ID == Steam.getLobbyOwner(NetworkManager.LOBBY_ID):
			NetworkManager.IS_READY[member_steam_id] = false

		else:
			start_btn.hide()
			start_btn.disabled = true
			
# A user's information has changed
func _on_persona_change(this_steam_id: int, _flag: int) -> void:
	# Make sure you're in a lobby and this user is valid or Steam might spam your console log
	if NetworkManager.LOBBY_ID > 0:
		print("A user (%s) had information change, update the lobby list" % this_steam_id)
		# Update the player list
		get_lobby_members()
		
func add_member_to_list(steam_id: int, steam_name: String):
	print("Adding new player to the list: "+str(steam_id)+" / "+str(steam_name))
	# Add them to the list
	NetworkManager.LOBBY_MEMBERS.append({"steam_id":steam_id, "steam_name":steam_name })
	# Instance the lobby member object
	var THIS_MEMBER: Object = lobby_member.instantiate()
	# Add their Steam name and ID
	THIS_MEMBER.name = str(steam_id)
	THIS_MEMBER._set_Member(steam_id, steam_name)
	# Add the child node
	$MembersPnl/MarginContainer/ScrollContainer/VBoxContainer.add_child(THIS_MEMBER)
	

#region P2PHandshake
func make_p2p_handshake() -> void:
	print("Sending P2P handshake to the lobby")
	P2P._send_P2P_Packet(0,0, {"message": "handshake", "from": NetworkManager.STEAM_ID},Steam.P2P_SEND_RELIABLE)
	
func _on_p2p_session_request(remote_id: int) -> void:
	# Get the requester's name
	var this_requester: String = Steam.getFriendPersonaName(remote_id)
	print("%s is requesting a P2P session" % this_requester)
	# Accept the P2P session; can apply logic to deny this request if needed
	Steam.acceptP2PSessionWithUser(remote_id)
	# Make the initial handshake
	make_p2p_handshake()
#endregion
	
#region LobbyEvents
func _on_p2p_session_connect_fail(lobby_id: int, session_error: int) -> void:
	# Note the session errors are: 0 - none, 1 - target user not running the same game, 2 - local user doesn't own app, 3 - target user isn't connected to Steam, 4 - connection timed out, 5 - unused
	# If no error was given
	if session_error == 0:
		print("[WARNING] Session failure with "+str(lobby_id)+" [no error given].")
	# Else if target user was not running the same game
	elif session_error == 1:
		print("[WARNING] Session failure with "+str(lobby_id)+" [target user not running the same game].")
	# Else if local user doesn't own app / game
	elif session_error == 2:
		print("[WARNING] Session failure with "+str(lobby_id)+" [local user doesn't own app / game].")
	# Else if target user isn't connected to Steam
	elif session_error == 3:
		print("[WARNING] Session failure with "+str(lobby_id)+" [target user isn't connected to Steam].")
	# Else if connection timed out
	elif session_error == 4:
		print("[WARNING] Session failure with "+str(lobby_id)+" [connection timed out].")
	# Else if unused
	elif session_error == 5:
		print("[WARNING] Session failure with "+str(lobby_id)+" [unused].")
	# Else no known error
	else:
		print("[WARNING] Session failure with "+str(lobby_id)+" [unknown error "+str(session_error)+"].")
		
func _on_lobby_chat_update(this_lobby_id: int, change_id: int, making_change_id: int, chat_state: int) -> void:
	# Get the user who has made the lobby change
	var changer_name: String = Steam.getFriendPersonaName(change_id)

	# If a player has joined the lobby
	if chat_state == Steam.CHAT_MEMBER_STATE_CHANGE_ENTERED:
		print("%s has joined the lobby." % changer_name)

	# Else if a player has left the lobby
	elif chat_state == Steam.CHAT_MEMBER_STATE_CHANGE_LEFT:
		print("%s has left the lobby." % changer_name)

	# Else if a player has been kicked
	elif chat_state == Steam.CHAT_MEMBER_STATE_CHANGE_KICKED:
		print("%s has been kicked from the lobby." % changer_name)

	# Else if a player has been banned
	elif chat_state == Steam.CHAT_MEMBER_STATE_CHANGE_BANNED:
		print("%s has been banned from the lobby." % changer_name)

	# Else there was some unknown change
	else:
		print("%s did... something." % changer_name)

	# Update the lobby now that a change has occurred
	get_lobby_members()
#endregion
		
func _on_ready_btn_pressed():
	
	if NetworkManager.STEAM_ID == Steam.getLobbyOwner(NetworkManager.LOBBY_ID):
		im_ready = !im_ready
		#for ready in NetworkManager.IS_READY.keys():
			#if ready == NetworkManager.STEAM_ID:
		NetworkManager.IS_READY[NetworkManager.STEAM_ID] = im_ready
	else:
		im_ready = !im_ready
		P2P._send_P2P_Packet(0,Steam.getLobbyOwner(NetworkManager.LOBBY_ID),{"TYPE":NetworkManager.TYPES.READY,"steam_id":NetworkManager.STEAM_ID,"ready":im_ready},Steam.P2P_SEND_RELIABLE)

func _on_start_btn_pressed():
	if NetworkManager.STEAM_ID == Steam.getLobbyOwner(NetworkManager.LOBBY_ID):
		var result = NetworkManager.IS_READY.values().all(func(number): return number == true)
		if result:
			pass
			#SceneManager.change_scene("res://godotsteam_sync_example/Test.tscn")