extends Node


signal players_changed

var players = {}


func _ready():
	multiplayer.connected_to_server.connect(_on_connected_to_server)
	multiplayer.peer_connected.connect(_on_peer_connected)
	multiplayer.peer_disconnected.connect(_on_peer_disconnected)
	
	multiplayer.allow_object_decoding = true


func host_game(port):
	var peer = ENetMultiplayerPeer.new()
	peer.create_server(int(port))
	
	multiplayer.multiplayer_peer = peer
	
	Client.player.id = multiplayer.get_unique_id()
	%Players.add_child(Client.player)

func join_game(ip, port):
	var peer = ENetMultiplayerPeer.new()
	peer.create_client(ip, int(port))
	
	multiplayer.multiplayer_peer = peer
	
	Client.player.id = multiplayer.get_unique_id()


func _on_connected_to_server():
	print(multiplayer.get_unique_id(), ": connected to server")

func _on_peer_connected(id):
	print(multiplayer.get_unique_id(), ": peer connected: ", id)
	
	if id == 1: # tell host to add player
		add_to_players.rpc_id(1, inst_to_dict(Client.player))
		Client._player = null
	# TODO: add existing towers to new peers

func _on_peer_disconnected(id):
	print(multiplayer.get_unique_id(), ": peer disconnected: ", id)
	# TODO: move towers owned by peer to host
	
	if id == 1: # if host disconnected go back to Lobby
		get_tree().change_scene_to_file("res://UI/Lobby.tscn")


func get_player(id: int) -> Player:
	return %Players.get_node(str(id))

func get_ordered_player_ids(): # TODO: return type needed for players_list.gd "find" method?
	var keys = %Players.get_children().map(func(item: Player):
		return item.id
	)
	keys = keys.filter(func(item: int): # workaround for MultiplayerSpawner + Synchronizer
		return item != 0
	)
	keys.sort_custom(func(a: int, b: int):
		return int(str(a).substr(0, 8)) < int(str(b).substr(0, 8))
	)
	
	return keys


@rpc("any_peer")
func add_to_players(remote_data: Dictionary):
	var id = multiplayer.get_remote_sender_id()
	
	var player = preload("res://Game/Player.tscn").instantiate()
	player.id = id
	player.username = remote_data.username
	
	%Players.add_child(player)
	
	players_changed.emit()


@rpc("any_peer")
#func place_tower(remote_tower: Dictionary, position: Vector2):
func place_tower(remote_data: Dictionary):
	var data: Tower.NetworkData = dict_to_inst(remote_data)
	var remote_player_id = multiplayer.get_remote_sender_id()
	
	var tower = Tower.from_network_data(data)
	tower.owner_id = remote_player_id
	
	Network.get_player(remote_player_id).towers[tower.global_position] = tower
	
	Client.stage.place_tower(tower, tower.global_position)


@rpc("any_peer")
#func destroy_tower(remote_tower: Dictionary):
func destroy_tower(position: Vector2):
	var owner_id = multiplayer.get_remote_sender_id()
	var player = get_player(owner_id)
	var tower = player.towers.get(position)
	
	Client.stage.destroy_tower(tower)


@rpc("any_peer")
func update_tower(remote_tower_node_path: NodePath, remote_data: Dictionary):
	var data: Tower.NetworkData = dict_to_inst(remote_data)
	var tower: Tower = get_tree().current_scene.get_node_or_null(remote_tower_node_path)
	
	if tower:
		tower.update_with_network_data(data)


@rpc("any_peer")
func spawn_unit(remote_data: Dictionary):#, _remote_spawn: Dictionary):
	#print(remote_data)
	var data: Unit.NetworkData = dict_to_inst(remote_data)
	var unit := Unit.from_network_data(data)
	#var spawn = from_rpc_object(remote_spawn, "res://Stages/Paths/Spawn.tscn")
	
	var remote_id = multiplayer.get_remote_sender_id()
	unit.owner_id = remote_id
	#unit.set_multiplayer_authority(remote_id)
	
	Client.stage.spawn_unit(unit)


@rpc("any_peer")
func remove_unit(remote_unit_node_path):
	var unit = get_tree().current_scene.get_node_or_null(remote_unit_node_path)
	if unit:
		unit.queue_free()


@rpc("any_peer")
func update_unit(remote_unit_node_path, data):
	var unit: Unit = get_tree().current_scene.get_node_or_null(remote_unit_node_path)
	if unit:
		if "hp" in data:
			unit.hp = data.hp
		if "position" in data:
			unit.position = data.position
		if "sprite" in data:
			unit.get_node("Sprite2D").self_modulate = data.sprite.self_modulate
		if "current_path" in data:
			unit.current_path = data.current_path
			unit.line.points = PackedVector2Array(data.current_path)
		if "current_path_idx" in data:
			unit.current_path_idx = data.current_path_idx