extends Node

const MAX_PEERS = 4

var world_scene = preload("res://scenes/game/world.tscn")
var player_scene = preload("res://scenes/player/Player.tscn")
var human_player_scene = preload("res://scenes/player/HumanPlayer.tscn")
var bot_player_scene = preload("res://scenes/player/BotPlayer.tscn")

var players = {}

var game_running:bool = false

var game_ready_timer:Timer

signal players_changed(players)
signal connection_failed()
signal connection_succeeded()
signal server_disconnected()
signal game_ready(ready)
signal game_started()
signal game_ended()
signal game_error(type, data)

func _ready():
	var arguments = {}
	for argument in OS.get_cmdline_args():
		if argument.split("=")[0] == "port":
			host_game(int(argument.split("=")[1]))
				
func host_game(port:int):
	var host = NetworkedMultiplayerENet.new()
	host.create_server(port, MAX_PEERS)
	get_tree().set_network_peer(host)
	get_tree().connect("network_peer_connected", self, "_player_connected")
	get_tree().connect("network_peer_disconnected", self,"_player_disconnected")
	game_ready_timer = Timer.new()
	get_tree().get_root().add_child(game_ready_timer)
	game_ready_timer.set_one_shot(true)
	game_ready_timer.set_wait_time(3)
	game_ready_timer.connect("timeout",self,"start_game")
	
func join_game(ip, port:int):
	get_tree().connect("connected_to_server", self, "_connected_ok")
	get_tree().connect("connection_failed", self, "_connected_fail")
	get_tree().connect("server_disconnected", self, "_server_disconnected")
	var host = NetworkedMultiplayerENet.new()
	host.create_client(ip, port)
	get_tree().set_network_peer(host)
	
func _connected_ok():
	rpc("set_player", get_tree().get_network_unique_id())
	emit_signal("connection_succeeded")
	
func _connected_fail():
	get_tree().set_network_peer(null)
	emit_signal("connection_failed")
	
func _server_disconnected():
	get_tree().set_network_peer(null)
	emit_signal("server_disconnected")

func _player_disconnected(id):
	if (get_tree().is_network_server()):
		if game_running: # Game is in progress
			emit_signal("game_error", "DISCONNECTED", [id])
			# TODO!
		else: 
			remove_player(id)

remote func set_player(id, new_name:String = " ", new_color:Color = Color.black, new_ready:bool = false):
	players[id] = {"name" : new_name, "color" : new_color, "ready" : new_ready, "prepared" : false}
	emit_signal("players_changed", players)
	
	if get_tree().is_network_server():
		var all_ready = true
		for p_id in players: 
			rpc_id(id, "set_player", p_id, players[p_id].name, players[p_id].color, new_ready) 
			rpc_id(p_id, "set_player", id, new_name, new_color, new_ready)
			all_ready = all_ready && players[p_id].ready
		if all_ready:
			game_ready_timer.start()
			print("all_ready!")
		else:
			game_ready_timer.stop()
		emit_signal("game_ready", all_ready)
			
func update_player(new_name:String = " ", new_color:Color = Color.black, new_ready:bool = false):
	if get_tree().is_network_server():
		set_player(get_tree().get_network_unique_id(), new_name, new_color, new_ready)
	else:
		game.rpc("set_player",get_tree().get_network_unique_id(), new_name, new_color, new_ready)
		
remote func remove_player(id):
	players.erase(id)
	if (get_tree().is_network_server()):
		for p_id in players: 
			rpc_id(p_id, "remove_player", id)
	
	emit_signal("players_changed", players)

remotesync func prepare_game(bots:bool):
	
	get_tree().set_pause(true)
	
	var world = world_scene.instance()
	get_tree().get_root().add_child(world)

	get_tree().get_root().get_node("main_menu").hide()
	
	for p_id in players:
		var controls
		var player = players[p_id]
		
		var _player_scene = player_scene.instance()
		_player_scene.set_network_master(p_id)
		_player_scene.set_name(str(p_id))
		_player_scene.set_player_name(player.name)
		_player_scene.set_player_color(player.color)
		world.get_node("players").add_child(_player_scene)
		
		if p_id == get_tree().get_network_unique_id():
			controls = human_player_scene.instance()
			controls.set_name("HumanControl_" + str(p_id))
			world.add_child(controls)
			controls.set_player(_player_scene.get_path())
			controls.set_network_master(p_id)
		
		_player_scene.set_start(_player_scene.get_index())
	
	if bots:
		for index in range(MAX_PEERS-players.size()):
			var bot_index = players.size() + index
			var _player_scene = player_scene.instance()
			_player_scene.set_name("bot_player" + str(bot_index))
			world.get_node("players").add_child(_player_scene)
			_player_scene.add_to_group("bots")
			if get_tree().is_network_server():
				var bot = bot_player_scene.instance()
				bot.set_name("bot" + str(bot_index))
				world.add_child(bot)
				bot.set_player(_player_scene.get_path())
				bot.set_network_master(get_tree().get_network_unique_id())
			_player_scene.set_start(bot_index)

	rpc_id(1, "player_prepared", get_tree().get_network_unique_id())

func start_game():
	rpc("prepare_game", false)

remotesync func player_prepared(id):
	if (get_tree().is_network_server()):
		players[id].prepared = true
		var all_prepared = true
		for p_id in players: 
			all_prepared = all_prepared && players[p_id].prepared
		if all_prepared:
			rpc("post_start_game")
	
remotesync func post_start_game():
	get_tree().set_pause(false)
	game_running = true
	emit_signal("game_started")

func local_game(name:String, color:Color, bots:bool):
	var localhost = NetworkedMultiplayerENet.new()
	localhost.create_server(0, 0)
	get_tree().set_network_peer(localhost)
	players[get_tree().get_network_unique_id()] = { "name" : name, "color" : color }
	prepare_game(bots)
	post_start_game()
	
func quit_game():
	if (has_node("/root/world")): 
		get_node("/root/world").queue_free()

	players.clear()
	get_tree().set_network_peer(null)
	get_tree().get_root().get_node("main_menu").show()
	game_running = false