extends Control
class_name LocalMultiplayer

onready var gameconfig := $"%GameConfig"

var in_game := false

enum MODES { PVP, PVE, EVE }
enum { HUMAN, ENGINE }

var mode: int = -1

var board_engine_bridge: BoardEngineBridge = null

var ui: GameUI


func create(moves: PoolStringArray, player1_color: bool, players: PoolIntArray, engine_depth: int) -> void:
	assign_mode(players)
	Globals.local = self
	ui = load("res://ui/board/Game.tscn").instance()
	var b: Grid = ui.get_board() as Grid
	b.local = true
	Log.debug("Set board team to %s" % Utils.expand_color(b.team))
	get_tree().get_root().add_child(ui)
	PacketHandler.lobby.toggle(false)
	match mode:
		MODES.PVP:
			b.auto_change_team = true
			b.team = "w"
			ui._on_info({name = "Anonymous", country = "rainbow"})
		MODES.PVE:
			b.team = "w" if player1_color == true else "b"
			board_engine_bridge = BoardEngineBridge.new(b, [Chess.__swap_color(b.team)], get_tree(), engine_depth)
			ui._on_info(BoardEngineBridge.info)
			board_engine_bridge.connect("nps", self, "set_nps", [1 if player1_color == true else 0])
			board_engine_bridge.connect("depth", self, "set_thinking", [1 if player1_color == true else 0])
			if board_engine_bridge.is_ready() == false:
				var engine_p: UserPanel = ui.panels[int(Globals.grid.team == "w")]
				engine_p.loading = true
				board_engine_bridge.connect("ready", engine_p, "set_loading", [false])
		MODES.EVE:
			b.team = b.chess.turn
			Globals.spectating = true
			board_engine_bridge = BoardEngineBridge.new(b, ["w", "b"], get_tree(), engine_depth)
			ui._spectate_info({white = BoardEngineBridge.info, black = BoardEngineBridge.info})
			board_engine_bridge.connect("nps", self, "set_nps")
			board_engine_bridge.connect("depth", self, "set_thinking")
			if board_engine_bridge.is_ready() == false:
				for e_p in ui.panels:
					e_p.loading = true
					board_engine_bridge.connect("ready", e_p, "set_loading", [false])

	get_tree().call_group("backbutton", "queue_free")

	yield(get_tree(), "idle_frame")
	if mode in [MODES.EVE, MODES.PVE]:
		for panel in ui.panels:
			panel.thinking_display.max_value = engine_depth

	b.load_pgn(moves.join(" "))  # load_pgn emits Events.turn_over
	b.auto_flip()
	Globals.chat.hide()
	in_game = true


func flip_int(i: int) -> int:
	return 1 if i == 0 else 0


func set_nps(nps: int, on: int = 0 if board_engine_bridge.turn == "w" else 1) -> void:
	if is_instance_valid(ui.panels[on]):
		ui.panels[on].nps = nps
		ui.panels[flip_int(on)].nps = 0  # turn it off


#                 thinking: depth
func set_thinking(thinking: int, on: int = 0 if board_engine_bridge.turn == "w" else 1):
	if is_instance_valid(ui.panels[on]):
		if thinking == 0 || ui.panels[on].thinking < thinking:  # depth can go down too
			ui.panels[on].thinking = thinking
		ui.panels[flip_int(on)].thinking = 0


func assign_mode(players: PoolIntArray) -> void:
	if players.count(HUMAN) == 2:
		mode = MODES.PVP
	elif players.count(ENGINE) == 2:
		mode = MODES.EVE
	else:
		mode = MODES.PVE


func _pressed():
	if gameconfig.visible:
		create(gameconfig.moves, gameconfig.color, gameconfig.players, gameconfig.depth)
		gameconfig.hide()
	else:
		gameconfig.show()


func _input(_event):
	if Input.is_action_pressed("ui_cancel") and Globals.local and in_game:
		Events.emit_signal("go_back", "", true)


func _init() -> void:
	Events.connect("go_back", self, "go_back")


func go_back(_reason: String, _isok: bool) -> void:
	if in_game:
		in_game = false
		if board_engine_bridge:
			board_engine_bridge.kill()
			board_engine_bridge = null
		PacketHandler.go_back("", true)
		get_node("/root/Game").queue_free()
		PacketHandler.lobby.toggle(true)
		Globals.reset_vars()
		get_parent().current_tab = get_parent().get_children().find(self)


func undo(two: bool = false) -> void:
	board_engine_bridge.undo(two)


class BoardEngineBridge:
	extends Reference
	signal nps(nps)
	signal depth(depth)
	# warning-ignore:unused_signal
	signal ready  # is emitted by connect_signals[#l4]

	const info := {name = "Stockfish", country = "antartica"}

	var b: Grid
	var stockfish: Stockfish
	var playing := PoolStringArray()
	var tree: SceneTree
	var depth: int
	var searching: bool = false
	var ready: bool setget , is_ready

	var turn: String = "" setget , get_turn

	func get_turn() -> String:
		return stockfish.game.turn

	func is_ready() -> bool:
		return stockfish.engine_ready

	func _init(board: Grid, teams: PoolStringArray, _tree: SceneTree, _depth: int) -> void:
		depth = _depth
		tree = _tree
		playing = teams
		b = board
		var loader = StockfishLoader.new()
		stockfish = loader.load_stockfish()
		stockfish.game = b.chess
		connect_signals()

	func connect_signals():
		stockfish.connect("info", self, "_info")
		stockfish.connect("bestmove", self, "clear_arrows")
		stockfish.connect("bestmove", self, "play_bestmove")
		stockfish.connect("engine_ready", self, "emit_signal", ["ready"])
		Events.connect("turn_over", self, "turn_over")

	func undo(two: bool = false) -> void:
		stockfish.stop()
		b.undo(two)
		set_engine_position()

	func _info(info: Dictionary):
		if searching == false:
			return
		if info.get("nps", false):
			emit_signal("nps", info.nps)
		if info.get("depth", false):
			emit_signal("depth", info.depth)
		if info.get("pv", false):
			var bm = stockfish.game.__move_from_uci(info.pv[0])
			clear_arrows()
			var arrows := b.arrows
			var arrow: Dictionary = arrows.build_arrow(
				Chess.vecfrom0x88(bm.from), Chess.vecfrom0x88(bm.to), Color(0.286275, 0.564706, 0.768627)
			)
			arrow["engine_arrow"] = true
			arrows.arrows.append(arrow)
			arrows.shorten_arrows_at(Chess.vecfrom0x88(bm.to))

	func clear_arrows(_arg = ""):
		var good_array := []
		for arrow in b.arrows.arrows:
			if arrow.get("engine_arrow", false) == false:
				good_array.append(arrow)
		b.arrows.arrows = good_array

	func turn_over():
		set_engine_position()
		if stockfish.game.turn in playing:
			find_bestmove()

	# play_bestmove() will play the move when its found
	func find_bestmove():
		yield(tree, "idle_frame")
		stockfish.go(depth)
		searching = true

	func play_bestmove(move: Dictionary) -> void:
		emit_signal("depth", 0)
		emit_signal("nps", 0)
		b.move(move.san, false, false)

	func set_engine_position():
		stockfish._position()

	func kill() -> void:
		stockfish.kill()
		stockfish = null