extends TileMap

@export var board_state: Dictionary = Dictionary()

@onready var king = preload("res://King.tscn")
@onready var knight = preload("res://Knight.tscn")
@onready var rook = preload("res://Rook.tscn")
@onready var queen = preload("res://Queen.tscn")
@onready var bishop = preload("res://Bishop.tscn")
@onready var pawn = preload("res://Pawn.tscn")

# Called when the node enters the scene tree for the first time.
func _ready():
	setup_board()
	
	var children = get_children()
	for child in children:
		if child.has_signal("moved"):
			child.moved.connect(_on_piece_moved)
			board_state[child.grid_pos] = child

# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta):
	pass

func _on_piece_moved(piece, old_pos, new_pos):
	if board_state.has(new_pos):
		var destroyed = board_state[new_pos]
		if destroyed.is_king():
			get_tree().paused = true
		board_state.erase(new_pos)
		destroyed.queue_free()
	board_state.erase(old_pos)
	
	var new_piece = piece
	if piece.is_pawn():
		if piece.is_white() and new_pos.y == 0:
			new_piece = queen.instantiate()
			new_piece.grid_size = tile_set.tile_size
			new_piece.make_white()
			new_piece.grid_pos = new_pos
			add_child(new_piece)
			piece.queue_free()
		elif piece.is_black() and new_pos.y == 7:
			new_piece = queen.instantiate()
			new_piece.grid_size = tile_set.tile_size
			new_piece.make_black()
			new_piece.grid_pos = new_pos
			add_child(new_piece)
			piece.queue_free()
	board_state[new_pos] = new_piece
	
func setup_board():
	var king_instance = king.instantiate()
	king_instance.grid_size = tile_set.tile_size
	king_instance.make_white()
	king_instance.grid_pos = Vector2i(4,7)
	add_child(king_instance)
	
	var bking_instance = king.instantiate()
	bking_instance.grid_size = tile_set.tile_size
	bking_instance.make_black()
	bking_instance.grid_pos = Vector2i(4,0)
	add_child(bking_instance)
	
	var queen_instance = queen.instantiate()
	queen_instance.grid_size = tile_set.tile_size
	queen_instance.make_white()
	queen_instance.grid_pos = Vector2i(3,7)
	add_child(queen_instance)
	
	var bqueen_instance = queen.instantiate()
	bqueen_instance.grid_size = tile_set.tile_size
	bqueen_instance.make_black()
	bqueen_instance.grid_pos = Vector2i(3,0)
	add_child(bqueen_instance)
	
	for x in [1, 6]:
		var knight_instance = knight.instantiate()
		knight_instance.grid_size = tile_set.tile_size
		knight_instance.make_white()
		knight_instance.grid_pos = Vector2i(x,7)
		add_child(knight_instance)
		
		var bknight_instance = knight.instantiate()
		bknight_instance.grid_size = tile_set.tile_size
		bknight_instance.make_black()
		bknight_instance.grid_pos = Vector2i(x,0)
		add_child(bknight_instance)
	
	for x in [0, 7]:
		var rook_instance = rook.instantiate()
		rook_instance.grid_size = tile_set.tile_size
		rook_instance.make_white()
		rook_instance.grid_pos = Vector2i(x,7)
		add_child(rook_instance)
		
		var brook_instance = rook.instantiate()
		brook_instance.grid_size = tile_set.tile_size
		brook_instance.make_black()
		brook_instance.grid_pos = Vector2i(x,0)
		add_child(brook_instance)
	
	for x in [2, 5]:
		var bishop_instance = bishop.instantiate()
		bishop_instance.grid_size = tile_set.tile_size
		bishop_instance.make_white()
		bishop_instance.grid_pos = Vector2i(x,7)
		add_child(bishop_instance)
		
		var bbishop_instance = bishop.instantiate()
		bbishop_instance.grid_size = tile_set.tile_size
		bbishop_instance.make_black()
		bbishop_instance.grid_pos = Vector2i(x,0)
		add_child(bbishop_instance)
	
	for x in range(0, 8):
		var pawn_instance = pawn.instantiate()
		pawn_instance.grid_size = tile_set.tile_size
		pawn_instance.make_white()
		pawn_instance.grid_pos = Vector2i(x,6)
		add_child(pawn_instance)
		
		var bpawn_instance = pawn.instantiate()
		bpawn_instance.grid_size = tile_set.tile_size
		bpawn_instance.make_black()
		bpawn_instance.grid_pos = Vector2i(x,1)
		add_child(bpawn_instance)