extends Control
class_name Grid

const PieceScene := preload("res://piece/Piece.tscn")
const Square := preload("res://Square.tscn")

### for the sandisplay
signal add_to_pgn(move)
signal clear_pgn
signal load_pgn(moves)
signal remove_last

var move_indicators: PoolIntArray = []

var rot: float = 0
var piece_size: Vector2

export(Color) var overlay_color: Color
export(Color) var premove_color: Color
export(Color) var last_move_indicator_color: Color
export(Color) var last_move_take_indicator: Color
export(Color) var clockrunning_color: Color
export(Color) var clockrunninglow: Color
export(Color) var clocklow: Color

var board = []  # has `get_piece(algebraic position)` and `set_piece(algebraic position)` for ease of use


func get_piece(alg: String) -> Piece:
	return board[Chess.SQUARE_MAP[alg]]


func set_piece(alg: String, p: Piece) -> void:
	board[Chess.SQUARE_MAP[alg]] = p


var flipped := false
var labels := {numbers = [], letters = []}
var background_array := []
var last_clicked: Piece
var premove: Dictionary = {}
var check_circle: GradientTexture2D = load("res://piece/check-circle.tres")
var take_circle: GradientTexture2D = load("res://piece/takeable-circle.tres")
var move_circle: GradientTexture2D = load("res://piece/move-circle.tres")

onready var game: GameUI = owner if owner is GameUI else null
onready var sidebar := game.get_node_or_null("%Sidebar") if game else null
onready var darken = $Darken
onready var foreground := $Foreground
onready var background := $Background
onready var pieces := $Pieces
onready var arrows := $"%Arrows"

var chess := Chess.new()
var local := false
var spectating := false
var team: String
var auto_change_team := false


func _init():
	Globals.grid = self


func _exit_tree():
	Globals.grid = null


func _process(_delta):
	rect_rotation = rot
	foreground.rect_rotation = rot
	if Input.is_action_just_pressed("debug") and Debug.debug:
		print(chess.ascii())


func _resized():
	var old_pc = piece_size
	piece_size = rect_size / 8
	piece_size.x = clamp(piece_size.x, 0, piece_size.y)
	piece_size.y = clamp(piece_size.y, 0, piece_size.x)
	check_circle.width = piece_size.x
	check_circle.height = piece_size.y
	take_circle.width = piece_size.x
	take_circle.height = piece_size.y
	move_circle.width = piece_size.x
	move_circle.height = piece_size.y
	if foreground:
		rect_pivot_offset = (piece_size * 8) / 2
		foreground.rect_pivot_offset = rect_pivot_offset
	if not (board.empty() && background_array.empty()) && piece_size != old_pc:
		resize_board()
		Log.debug("Resizing board")


func set_take_move_circle_color(
	color: Color = Color(overlay_color.r, overlay_color.g, overlay_color.b, .65)
) -> void:
	take_circle.gradient.colors[1] = color
	move_circle.gradient.colors[0] = color


func _ready():
	set_take_move_circle_color()
	_resized()
	Events.connect("turn_over", self, "_on_turn_over")
	PacketHandler.connect("move_data", self, "move", [false, false])
	create_pieces()
	create_squares()
	create_labels()
	yield(get_tree(), "idle_frame")
	if !team:
		team = chess.turn
		auto_change_team = true
	Log.debug("board: ready")


func resize_board():
	resize_pieces()


func create_squares() -> void:  # create the board
	background_array.resize(128)
	for i in Chess.SQUARE_MAP.values():
		var alg := Chess.algebraic(i)
		var square := Square.instance()  # create a square
		square.name = alg
		square.b = self
		square.square = alg
		square.hint_tooltip = alg
		square.color = (Globals.board_color1 if Chess.square_color(alg) == "light" else Globals.board_color2)  # set the color
		background.add_child(square)  # add the square to the background
		square.connect("clicked", self, "square_clicked", [square])  # connect the clicked event
		background_array[i] = square  # add the square to the background array
	arrows._setup(self)  # initialize the arrows


func create_labels() -> void:
	var font: DynamicFont = load("res://ui/ubuntu-bold-regular.tres").duplicate()
	font.size = 15
	for k in Chess.SQUARE_MAP:
		if k == "h1":
			var l = init_label(font, k, k[0], VALIGN_BOTTOM, 0, false)
			var n = init_label(font, k, k[1], 0, VALIGN_BOTTOM, false)
			var h = HBoxContainer.new()
			h.mouse_filter = MOUSE_FILTER_IGNORE
			for i in [l, n]:
				var ic = create_margin_container()
				ic.add_child(i)
				h.add_child(ic)
			labels.numbers.append(n)
			labels.letters.append(l)
			foreground.add_child(h)
		elif k[0] == "h":  # file h contains numbers
			labels.numbers.append(init_label(font, k, k[1], 0, VALIGN_BOTTOM))
		elif k[1] == "1":  # rank 1 contains letters
			labels.letters.append(init_label(font, k, k[0], VALIGN_BOTTOM))
		else:
			var spacer = Control.new()
			spacer.mouse_filter = MOUSE_FILTER_IGNORE
			spacer.name = k + "_space"
			spacer.size_flags_horizontal = SIZE_EXPAND_FILL
			spacer.size_flags_vertical = SIZE_EXPAND_FILL
			foreground.add_child(spacer)


func init_label(font: DynamicFont, alg: String, text: String, valign := 0, align := 0, add := true) -> Label:
	var label := Label.new()
	label.align = align
	label.valign = valign
	label.size_flags_horizontal = SIZE_EXPAND_FILL
	label.size_flags_vertical = SIZE_EXPAND_FILL
	label.mouse_filter = MOUSE_FILTER_IGNORE
	label.name = text
	label.text = text
	label.add_color_override(
		"font_color", Globals.board_color1 if Chess.square_color(alg) == "dark" else Globals.board_color2
	)
	label.add_font_override("font", font)
	if add:
		var container := create_margin_container()
		container.add_child(label)
		foreground.add_child(container)
	return label


func create_margin_container(margin := 5) -> MarginContainer:
	var c := MarginContainer.new()
	c.add_constant_override("margin_top", margin)
	c.add_constant_override("margin_left", margin)
	c.add_constant_override("margin_right", margin)
	c.add_constant_override("margin_bottom", margin)
	c.size_flags_horizontal = SIZE_EXPAND_FILL
	c.size_flags_vertical = SIZE_EXPAND_FILL
	c.mouse_filter = MOUSE_FILTER_IGNORE
	return c


func clear_pieces() -> void:
	for i in Chess.SQUARE_MAP.values():
		var p: Piece = board[i]
		if p:
			p.queue_free()
			board[i] = null


func resize_pieces():
	for i in Chess.SQUARE_MAP.values():
		var p: Piece = board[i]
		if p:
			p.size()


func create_pieces():
	board.resize(128)
	for k in Chess.SQUARE_MAP:
		var piece = chess.get(k)
		if piece:
			make_piece(k, piece.type, piece.color)


func make_piece(algebraic: String, piece_type: String, color := "w") -> void:  # make peace
	var piece := PieceScene.instance()  # create a piece
	piece.name = "%s-%s" % [piece_type, algebraic]
	piece.b = self
	piece.position = algebraic
	piece.type = piece_type
	piece.color = color
	pieces.add_child(piece)  # add the piece to the grid
	set_piece(algebraic, piece)


func flip_pieces() -> void:
	for i in Chess.SQUARE_MAP.values():
		var spot: Piece = board[i]
		if spot:
			spot.sprite.flip_v = flipped
			spot.sprite.flip_h = flipped


func flip_labels() -> void:
	for i in range(8):
		var numlabel: Label = labels.numbers[i]
		var letlabel: Label = labels.letters[i]
		var number := i + 1 if flipped else 8 - i
		numlabel.text = str(number)
		letlabel.text = "hgfedcba"[number - 1]


func flip_board() -> void:
	rot = 0 if rot == 180 else 180
	flipped = rot == 180
	Log.debug(["Flipped the board, now", "flipped" if flipped else "not flipped"])
	if sidebar:
		sidebar.flip_panels()
	flip_pieces()
	flip_labels()


func is_my_turn() -> bool:
	return team == chess.turn


func square_clicked(clicked_square: BackgroundSquare) -> void:
	if Globals.spectating:
		return

	var p := get_piece(clicked_square.square)

	if not is_my_turn() and is_instance_valid(last_clicked):
		# PREMOVE AREA
		var p_sq: int = Chess.SQUARE_MAP[clicked_square.square]
		for m in chess.piece_moves(last_clicked.position, last_clicked.type, team):
			if m.to == p_sq && m.from == Chess.SQUARE_MAP[last_clicked.position]:
				if "from" in premove and "to" in premove:
					background_array[premove.from].premove_indicator.hide()  # hide premove indicators
					background_array[premove.to].premove_indicator.hide()
				if premove && premove.from == m.from && premove.to == m.to:
					premove = {}
					Log.debug("De-selected premove")
				else:
					premove = m
					background_array[premove.from].premove_indicator.show()
					background_array[premove.to].premove_indicator.show()
					if premove.flags & Chess.BITS.PROMOTION:
						p.open_promotion_previews(darken)
						premove.promotion = yield(p, "promotion_decided")
					Log.debug("Selected premove: %s" % premove)
					clear_last_clicked()
					return
	elif (!p or p.color != team) and is_instance_valid(last_clicked):
		# Attempt to make the move (NORMAL MOVE AREA)
		for m in chess.moves({square = last_clicked.position, verbose = true}):
			if m.to == clicked_square.square && m.from == last_clicked.position:
				move(m.san)
				clear_last_clicked()
				return

	clear_last_clicked()

	if p and p.color == team:
		if chess.turn != team:
			if !Globals.premoves:
				return
			clicked_square.show_premove_indicators()
		else:
			clicked_square.show_move_indicators()
		last_clicked = p


func move(san: String, send := true, create_promotion_input := true) -> void:
	var sound_handled = false
	var move_0x88 = chess.__move_from_san(san, true)
	var valid_moves = chess.moves({square = chess.algebraic(move_0x88.from), stripped = true})
	if valid_moves.find(chess.stripped_san(san)) == -1:
		Log.err("Invalid move " + san)
		return
	Log.debug("Making move " + san)
	chess.__make_move(move_0x88)
	if move_0x88.flags & Chess.BITS.CAPTURE:
		board[move_0x88.to].took()
		SoundFx.play("Capture")
		sound_handled = true
	elif move_0x88.flags & Chess.BITS.EP_CAPTURE:
		var to_take := Chess.offset(move_0x88.to, Vector2(0, 1 * -1 if chess.turn == Chess.WHITE else 1))
		get_piece(to_take).took()
		SoundFx.play("Capture")
		sound_handled = true
	elif move_0x88.flags & Chess.BITS.KSIDE_CASTLE:  # kingside castling
		var rook_pos := Chess.offset(move_0x88.to, Vector2(1, 0))
		get_piece(rook_pos).move(Chess.offset(move_0x88.to, Vector2(-1, 0)))
	elif move_0x88.flags & Chess.BITS.QSIDE_CASTLE:  # queenside
		var rook_pos := Chess.offset(move_0x88.to, Vector2(-2, 0))
		get_piece(rook_pos).move(Chess.offset(move_0x88.to, Vector2(1, 0)))
	if move_0x88.flags & Chess.BITS.PROMOTION:  #promotion wow
		var p: Piece = yield(board[move_0x88.from].move(Chess.algebraic(move_0x88.to), true), "completed")
		if create_promotion_input:
			p.open_promotion_previews(darken)
			move_0x88.promotion = yield(p, "promotion_decided")
			san = chess.__move_to_san(move_0x88)  # update the san with new promotion data
			p.queue_free()
		else:  # was opponents turn, this is opponents move: promotion is already chosen
			p.queue_free()
		make_piece(p.position, move_0x88.promotion, p.color)
		SoundFx.play("Move" if move_0x88.flags & Chess.BITS.NORMAL else "Capture")
		sound_handled = true
	else:  # not promotion: from **always** moves to `to`
		var _p = board[move_0x88.from].move(Chess.algebraic(move_0x88.to))
	if send && !local:
		PacketHandler.send_mov(san)
	if !sound_handled:
		SoundFx.play("Move")
	emit_signal("add_to_pgn", san)
	Events.emit_signal("turn_over")


func clear_last_clicked():
	last_clicked = null


func draw(reason := "") -> void:
	var string = "draw by " + reason
	game.set_status(string, 0)
	SoundFx.play("Victory")
	Events.emit_signal("game_over", string)


func win(winner: String, reason := "") -> void:
	var string = "%s won the game by %s" % [Utils.expand_color(winner), reason]
	game.set_status(string, 0)  #: black won the game by checkmate
	Events.emit_signal("game_over", string)
	SoundFx.play("Victory")


func load_pgn(pgn: String) -> void:
	chess.load_pgn(pgn, {sloppy = true})
	clear_pieces()
	create_pieces()
	emit_signal("clear_pgn")
	var pgn_parser := PGN.new()
	var movs: PoolStringArray = pgn_parser.parse(pgn).moves
	emit_signal("load_pgn", movs)
	Log.info("load pgn " + pgn)
	Events.emit_signal("turn_over")


func undo(two: bool = false) -> void:
	Globals.chat.server("undid move %s" % chess.undo().san)
	emit_signal("remove_last")
	if two:
		Globals.chat.server("undid move %s" % chess.undo().san)
		emit_signal("remove_last")
	clear_pieces()
	clear_last_clicked()
	create_pieces()
	Events.emit_signal("turn_over")


func auto_flip():
	if team == Chess.WHITE and flipped:
		flip_board()
	elif team == Chess.BLACK and not flipped:
		flip_board()


func _on_turn_over():
	# if auto_change_team:
	# 	team = chess.turn
	# 	auto_flip()

	if is_my_turn():
		set_take_move_circle_color()
		# use the premove if possible
		if premove:
			background_array[premove.from].premove_indicator.hide()
			background_array[premove.to].premove_indicator.hide()
			if board[premove.from]:  # see if its valid
				if premove.flags & (Chess.BITS.CAPTURE | Chess.BITS.EP_CAPTURE) && not board[premove.to]:
					return
				var san = chess.__move_to_san(premove, chess.__generate_moves({legal = true}), false)
				if san:
					var legal_moves = chess.moves({square = chess.algebraic(premove.from), stripped = true})
					var is_possible_move = legal_moves.find(chess.stripped_san(san)) != -1
					if chess.__move_from_san(san, true) and (is_possible_move):  # it is valid
						Log.debug(["Executing premove:", san])
						move(san, true, false)  # make the move, send it to the opponent, dont prompt for premoves
					premove = {}
	elif Globals.premoves:
		set_take_move_circle_color(premove_color)
	SaveLoad.save("user://game.json", {pgn = chess.pgn(), fen = chess.fen()})
	clear_last_clicked()
	check_game_over()
	create_last_move_indicators()


func check_game_over():
	if chess.in_checkmate():
		# they won if its my turn, i won if its their turn.
		win(team if is_my_turn() else Chess.__swap_color(team), "checkmate")
	elif chess.half_moves >= 50:
		draw("fifty move rule")
	elif chess.in_stalemate():
		draw("stalemate")
	elif chess.insufficient_material():
		draw("insufficient material")
	elif chess.in_threefold_repetition():
		draw("threefold repetition")


func create_last_move_indicators():
	for i in move_indicators:
		background_array[i].move_indicator.color = last_move_indicator_color
		background_array[i].move_indicator.hide()
	if !chess.__history:
		return
	var m: Dictionary = chess.__history[-1].move
	background_array[m.from].move_indicator.show()
	if m.flags & Chess.BITS.CAPTURE:
		background_array[m.to].move_indicator.color = last_move_take_indicator
	background_array[m.to].move_indicator.show()
	move_indicators = [m.from, m.to]


func reload():
	premove = {}
	chess = Chess.new()
	clear_last_clicked()
	clear_pieces()
	create_pieces()
	create_last_move_indicators()  # it hides the indicators :/
	Events.emit_signal("turn_over")
	emit_signal("clear_pgn")  # clears the san displays