@tool
extends Pawn
class_name Knight

func _ready():
	self.texture = load("res://addons/Chess/Textures/WKnight.svg")
	Points = 3

func _process(_delta):
	if Item_Color != Temp_Color:
		Temp_Color = Item_Color
		if Item_Color == 0:
			self.texture = load("res://addons/Chess/Textures/WKnight.svg")
		elif Item_Color == 1:
			self.texture = load("res://addons/Chess/Textures/BKnight.svg")
			
func getValidMoves(board_flow, current_location: String) -> Dictionary:
	var moves = {
		"regular_moves": [],
		"special_moves": []
	}

	var loc = current_location.split("-")
	var x = int(loc[0])
	var y = int(loc[1])
	var game = board_flow.get_parent() as ChessGame

	# All possible L-shaped moves
	var knight_moves = [
		[-2, -1], [-2, 1],
		[-1, -2], [-1, 2],
		[1, -2], [1, 2],
		[2, -1], [2, 1]
	]

	for move in knight_moves:
		var target_x = x + move[0]
		var target_y = y + move[1]
		var new_loc = str(target_x) + "-" + str(target_y)
		
		if is_valid_cell(board_flow, new_loc):
			# Check tiles in the path
			var path_clear = true
			
			# Check horizontally first, then vertically (or vice versa)
			var check_horizontal_first = abs(move[0]) > abs(move[1])
			
			if check_horizontal_first:
				# Check horizontal movement
				var step_x = sign(move[0])
				for i in range(1, abs(move[0]) + 1):
					var path_tile_loc = str(x + (i * step_x)) + "-" + str(y)
					var tile = game.tileManager.get_tile(path_tile_loc)
					if tile && !tile.jumpable:
						path_clear = false
						break
				
				# Check vertical movement if path still clear
				if path_clear:
					var step_y = sign(move[1])
					var path_tile_loc = str(target_x) + "-" + str(y + step_y)
					var tile = game.tileManager.get_tile(path_tile_loc)
					if tile && !tile.jumpable:
						path_clear = false
			else:
				# Check vertical movement
				var step_y = sign(move[1])
				for i in range(1, abs(move[1]) + 1):
					var path_tile_loc = str(x) + "-" + str(y + (i * step_y))
					var tile = game.tileManager.get_tile(path_tile_loc)
					if tile && !tile.jumpable:
						path_clear = false
						break
				
				# Check horizontal movement if path still clear
				if path_clear:
					var step_x = sign(move[0])
					var path_tile_loc = str(x + step_x) + "-" + str(target_y)
					var tile = game.tileManager.get_tile(path_tile_loc)
					if tile && !tile.jumpable:
						path_clear = false

			# Only add the move if the path is clear and the destination is valid
			if path_clear && (can_move_to_cell(board_flow, new_loc) || can_move_to_cell(board_flow, new_loc, true)):
				moves.regular_moves.append(new_loc)

	return moves


func animate_movement(target_position: Vector2, duration: float = 0.5) -> void:
	z_index = 1
	var tween = create_tween()
	tween.set_trans(Tween.TRANS_LINEAR)
	tween.set_ease(Tween.EASE_IN_OUT)

	var start_pos = global_position
	var total_delta = target_position - start_pos
	var mid_pos: Vector2

	var cell_delta_x = int(total_delta.x / 50)
	var cell_delta_y = int(total_delta.y / 50)

	if abs(cell_delta_x) > abs(cell_delta_y):
		# Moving more horizontally ([-2, ±1])
		mid_pos = Vector2(
			start_pos.x + (cell_delta_x * 50),
			start_pos.y
		)
	else:
		# Moving more vertically ([±1, -2])
		mid_pos = Vector2(
			start_pos.x,
			start_pos.y + (cell_delta_y * 50)
		)

	# First move (longer distance)
	tween.tween_property(self, "global_position", mid_pos, duration/2)
	# Second move (shorter distance)
	tween.tween_property(self, "global_position", target_position, duration/2)

	await tween.finished
	z_index = 0