extends Network

var lobby: Lobby = null
var reconnecting = false
signal hosting(newhosting)
signal signal_recieved(what)
signal chat(text)
signal undo(undo)
signal info_recieved(info)
signal start_game
signal move_data(data)
signal load_pgn(pgn)
signal request_result(what)  # join/host true accepted, false rejected
signal rematch_result(what)
## for accounts(mostly)
signal signinresult(what)
signal signupresult(what)

const DEFAULT_ERROR_MESSAGE = "Error. Please report this issue to bendn."
const HEADERS := {
	"joinrequest": "J",
	"hostrequest": "H",
	"signup": "C",
	"signin": ">",
	"relay": "R",  # relay goes to both
	"signal": "S",  # signal is one way
	"loadpgn": "L",  # server telling me to load a pgn
	"info": "I",
	"move": "M",
	"undo": "<",
	"rematch": "r",
	"spectate": "0"  # its a eye you see
}

var game_code := ""

const RELAYHEADERS := {chat = "C"}
const SIGNALHEADERS := {takeback = "T", draw = "D", resign = "R", info = "I"}  # subheaders for HEADERS.signal

var hosting := false setget set_hosting
var leaving := false
var lock_lobby_status := false


func set_lobby_status(status: String, isok: bool) -> void:
	if !lock_lobby_status:
		lobby.set_status(status, isok)


func set_hosting(newhosting: bool) -> void:
	hosting = newhosting
	emit_signal("hosting", newhosting)


func return() -> void:  # return to the void
	if hosting:
		leaving = true
		set_hosting(false)


func _ready() -> void:
	Events.connect("go_back", self, "go_back")
	if Utils.internet and get_tree().get_root().has_node("StartMenu"):
		yield(get_tree().create_timer(.1), "timeout")
		open_connection()
		set_lobby_status("Connecting", true)
		connect("load_pgn", self, "load_pgn")


func load_pgn(pgn: String) -> void:
	if !Globals.grid:
		_start_game()
	yield(get_tree(), "idle_frame")
	Globals.grid.load_pgn(pgn)  # call deferred wont work since grid obj may be null


func _data_recieved() -> void:
	var data = ws.get_peer(1).get_var()
	Log.net(["RECIEVED:", data])
	var header: String = data.header
	var text = data.data
	match header:
		HEADERS.undo:
			emit_signal("undo", text)
		HEADERS.move:
			if !OS.is_window_focused() and !Debug.debug:  # dont be annoying in debug mode
				OS.request_attention()
			emit_signal("move_data", text.move)
		HEADERS.hostrequest:
			host_result(text)
		HEADERS.relay:
			var relay: Dictionary = text
			match relay.type:
				RELAYHEADERS.chat:
					emit_signal("chat", relay)
		HEADERS.joinrequest:
			join_result(text)
		HEADERS.info:
			yield(get_tree().create_timer(.5), "timeout")
			emit_signal("info_recieved", text)
		HEADERS.spectate:
			spectate_result(text)
		HEADERS.loadpgn:
			emit_signal("load_pgn", text)
		HEADERS.signal:
			var signal: Dictionary = text
			match signal.type:
				_:
					emit_signal("signal_recieved", signal)
		HEADERS.signup:
			emit_signal("signupresult", text)
		HEADERS.signin:
			emit_signal("signinresult", text)
		HEADERS.rematch:
			emit_signal("rematch_result", text)
		_:
			Log.err("unknown header %s" % header)


func _connection_established(protocol) -> void:
	._connection_established(protocol)


func _connection_closed(_was_clean_closed) -> void:
	._connection_closed(_was_clean_closed)
	var err = yield(rejoin(), "completed")
	if err:
		go_back("Connection closed, please check your internet, and reload the game.", false)


func _connection_error() -> void:
	._connection_error()
	var err = yield(rejoin(), "completed")
	if err:
		go_back("Connection error, please check your internet, and reload the game.", false)


const join_err_table := {
	"FULL": "This game is full. Double check your spelling, or host your own game..",
	"NOT_EXIST": "This game does not exist. Double check your spelling, or host it.",
	"NO_GAMECODE": "Your game name is empty.",
	"NO_ID": "Your id is undefined. Please report this issue to bendn."
}


func join_result(accepted) -> void:
	handle_result(accepted, "Joined!", join_err_table)


const host_err_table := {
	"ALREADY_EXISTS": "This game name is taken. Pick a new name.",  # game is full
	"ALREADY_EXISTS_EMPTY": "This game name is taken. Pick a new name, or join.",  # someone else hosted, but noone is joining them :(
	"NO_GAMECODE": "Your game name is empty.",
	"NO_ID": "Your id is undefined. Please report this issue to bendn."
}


func host_result(accepted) -> void:
	set_hosting(handle_result(accepted, "Hosted!", host_err_table))


const spectate_err_table := {"NOT_EXIST": "This game does not exist. Double check your spelling, or host it."}


func spectate_result(accepted) -> void:
	if handle_result(accepted, "Watching", spectate_err_table, true):
		Globals.spectating = true
		_start_game()
		yield(get_tree().create_timer(.5), "timeout")
		Globals.grid.load_pgn(accepted.pgn)
		emit_signal("info_recieved", accepted)


func handle_result(accepted, resultstring: String, err_table: Dictionary, quick_return := false) -> bool:
	var err = accepted.get("err", false)
	emit_signal("request_result", false if err else true)
	if !err:
		if quick_return:
			return true
		Globals.team = "w" if accepted.idx == 0 else "b"
		Log.debug("Team set to " + Utils.expand_color(Globals.team))
		set_lobby_status(resultstring, true)
		return true
	set_lobby_status(err_table.get(err, "Error. Please report this issue to bendn."), false)
	lobby.set_buttons(true)
	return false


func go_back(error: String, isok: bool) -> void:
	Globals.reset_vars()
	if Globals.playing:
		$"/root/Game".queue_free()
		set_lobby_status(error, isok)
		lobby.toggle(true)
		lobby.focus()
		lobby.set_buttons(true)


func _start_game() -> void:
	set_hosting(false)
	Log.debug("Created board")
	var ui: GameUI = load("res://ui/board/Game.tscn").instance()
	var b: Grid = ui.get_board() as Grid
	b.team = Globals.team
	Log.debug("Set board team to %s" % Utils.expand_color(b.team))
	get_tree().get_root().add_child(ui)
	b.spectating = Globals.spectating
	lobby.toggle(false)
	emit_signal("start_game")
	lobby.set_buttons(false)
	SoundFx.play("Victory")

	yield(get_tree(), "idle_frame")
	b.auto_flip()


func rejoin(tries := 5, interval := 2) -> int:  # on disconnect, try to rejoin
	var err = yield(open_connection(tries, interval), "completed")
	if reconnecting == true:
		return ERR_ALREADY_IN_USE
	reconnecting = true
	Log.info("reconnecting...")
	if not err:
		if Globals.playing:
			Log.info("reconnecting(rejoining)...")
			lock_lobby_status = true
			var rejoined = false
			for try in tries + 1:
				join_game()
				var result = yield(self, "request_result")
				if result:
					disconnect("load_pgn", self, "load_pgn")
					var pgn = yield(self, "load_pgn")
					if Globals.grid.chess.pgn() != pgn:
						Log.info("attempting to load %s" % pgn)
						Globals.grid.load_pgn(pgn)
					connect("load_pgn", self, "load_pgn")
					Log.info("reconnected(rejoined)!")
					rejoined = true
					break
			lock_lobby_status = false
			if rejoined == false:
				Log.err("reconnect failed(rejoin)!")
				reconnecting = false
				return ERR_INVALID_DATA
		else:  # not playing: just reconnect
			Log.info("reconnected!")
	else:
		Log.err("reconnect failed!")
	reconnecting = false
	return err


## packet sending wrapper functions
func signin(data):
	send_packet(data, HEADERS.signin)


func signup(data):
	send_packet(data, HEADERS.signup)


func signal(body: Dictionary, header: String, _mainheader := HEADERS.signal) -> Dictionary:
	var data: Dictionary = Utils.append_dict({"type": header}, body)
	send_packet(data, _mainheader)
	return data


func join_game(game: String = game_code) -> void:
	send_gamecode_packet(Creds.get_public(), HEADERS.joinrequest, game)


func host_game(game: String = game_code, white := true, moves_array: PoolStringArray = []) -> void:
	var pckt = Utils.append_dict(Creds.get_public(), {team = white, moves = moves_array})
	send_gamecode_packet(pckt, HEADERS.hostrequest, game)


func spectate(game: String = game_code) -> void:
	send_gamecode_packet(Creds.get_public(), HEADERS.spectate, game)


func send_gamecode_packet(data: Dictionary, header: String, gamecode: String = game_code):
	send_packet(Utils.append_dict({"gamecode": gamecode}, data), header)


func relay_signal(body: Dictionary, header: String) -> Dictionary:  # its really the same thing as signal()
	return signal(body, header, HEADERS.relay)


func send_mov(mov: String) -> void:
	send_packet({move = mov}, HEADERS.move)


static func construct_errstr(packet, err_table, default_message := DEFAULT_ERROR_MESSAGE) -> String:
	var errstr: String = ""
	var err: String = packet.get("err", false)
	if err:
		errstr = err_table.get(err, default_message)
		var stack = packet.get("stack", false)
		if stack:
			errstr += " (Stack trace: %s) " % stack
	return errstr