extends Node3D

# Managers
var movement_manager
var race_manager
var input_manager
var playerboard_manager
var action_manager
var special_tiles_manager
var powerup_manager

# Score tracking
var score: int = 0

# Display name (synced across network)
var _display_name: String = ""
var display_name: String:
	set(value):
		_display_name = value
		# Update label if it exists
		var name_label = get_node_or_null("Name")
		if name_label:
			name_label.text = _display_name
		
		# Sync to other peers if we are authority
		if is_multiplayer_authority() and is_inside_tree():
			rpc("sync_display_name", _display_name)
	get:
		return _display_name

# Special effect states
var is_frozen: bool = false
var is_invisible: bool = false
var original_movement_range: int = 1

# Tekton Interaction
var carried_tekton: Node3D = null
var is_carrying_tekton: bool:
	get: return is_carried_tekton
	set(value):
		is_carried_tekton = value
		# Visual/Logic side effects if any

var is_carried_tekton: bool = false
var is_attack_mode: bool = false:
	set(value):
		if is_attack_mode == value:
			return # Prevent infinite recursion / redundant updates
			
		is_attack_mode = value
		# Visual feedback for attack mode (Red Tint)
		if is_attack_mode:
			_apply_tint_recursive(self , Color(1.0, 0.5, 0.5))
		else:
			_apply_tint_recursive(self , Color.WHITE)
			
		# Sync to others if we are the authority
		if is_multiplayer_authority():
			rpc("sync_attack_mode", is_attack_mode)

@rpc("any_peer", "call_local", "reliable")
func sync_attack_mode(state: bool):
	# We WANT to trigger the setter to apply visuals on clients
	# Using self.var triggers setter in GDScript
	self.is_attack_mode = state

@export var is_bot: bool = false

@export var enhanced_gridmap_path: NodePath = "/root/Main/EnhancedGridMap"
var enhanced_gridmap: EnhancedGridMap
@export var current_position: Vector2i
var target_position: Vector2i = Vector2i(-1, -1) # For collision prediction
var is_player_moving: bool = false:
	get: return movement_manager.is_moving if movement_manager else false
	set(value): if movement_manager: movement_manager.is_moving = value

var _verify_timer: float = 0.0
var can_finish: bool:
	get: return race_manager.can_finish if race_manager else false
	set(value): if race_manager: race_manager.can_finish = value

@export var cell_size: Vector3 = Vector3(1, 0.05, 1)
@export var cell_offset: Vector3 = Vector3(0, 0, 0)

@export var goals: Array[int]:
	get: return race_manager.goals if race_manager else Array([], TYPE_INT, "", null) as Array[int]
	set(value): if race_manager: race_manager.goals = value

@export var playerboard: Array[int]:
	get: return race_manager.playerboard if race_manager else Array([], TYPE_INT, "", null) as Array[int]
	set(value): if race_manager: race_manager.playerboard = value

# Modifier for Turn based
var has_performed_action: bool = false
var _is_processing_action: bool = false
var selected_gridmap_position = Vector2i(-1, -1)
var selected_playerboard_slot = -1
var targeted_playerboard_slot = -1
var action_points: int = 2

# Modifier for player models
var rotation_speed: float = 10.0

var spawn_locations = [
	Vector2i(0, 0), # (0,1,0)
	Vector2i(0, 1), # (0,1,1)
	Vector2i(0, 2), # (0,1,2)
	Vector2i(0, 3), # (0,1,3)
	Vector2i(0, 4), # (0,1,4)
	Vector2i(0, 5), # (0,1,5)
	Vector2i(0, 6),
	Vector2i(0, 7),
	Vector2i(0, 8),
	Vector2i(0, 9),
	Vector2i(0, 10),
	Vector2i(0, 11),
	Vector2i(0, 12),
	Vector2i(0, 13)
]

# Add these as class variables at the top of the file
var finish_locations: Array:
	get: return race_manager.finish_locations if race_manager else []

var target_visual_position: Vector3 = Vector3.ZERO # For client-side smoothing

var spawn_point_selected = false

# Action for hilighter
var highlighted_spawn_points = []
var _is_highlighting: bool = false

# Character selection and animation
@onready var anim_player: AnimationPlayer = $AnimationPlayer
@onready var character_bob: Node3D = $Bob
@onready var character_masbro: Node3D = $Masbro
@onready var character_gatot: Node3D = $Gatot
@onready var character_oldpop: Node3D = $Oldpop

var selected_character: String = "Masbro" # Default character (matches tscn default visibility)
const AVAILABLE_CHARACTERS: Array[String] = ["Bob", "Masbro", "Gatot", "Oldpop"]


@export var movement_range: int = 1:
	set(value):
		movement_range = value
		if movement_manager: movement_manager.movement_range = value

@export var use_diagonal_movement: bool = false:
	set(value):
		use_diagonal_movement = value
		if enhanced_gridmap:
			enhanced_gridmap.set_diagonal_movement(value)
		if movement_manager: movement_manager.use_diagonal_movement = value

@export var is_my_turn: bool = false:
	set(value):
		is_my_turn = value
		if is_my_turn and is_multiplayer_authority():
			NotificationManager.send_message(self , NotificationManager.MESSAGES.TURN_START, NotificationManager.MessageType.NORMAL)
			
@export var has_moved_this_turn = false

# Track, Lap, Position
# Delegated to RaceManager

func _ready():
	# Ensure name is set first (node name = authority ID for multiplayer identification)
	# name = str(get_multiplayer_authority()) # CRITICAL FIX: Do NOT overwrite name. Bots have authority 1 but unique names (IDs).
	# Look up player's display name from LobbyManager
	var my_id = get_multiplayer_authority()
	
	print("[Player] _ready for %s (Auth: %s). Current display_name: '%s'" % [name, my_id, display_name])
	
	if is_bot or is_in_group("Bots"):
		# Bots get a unique name based on their Node Name (Bot ID)
		var bot_id = name.to_int()
		var bot_names = ["Bot", "Alpha", "Beta", "Gamma", "Delta"]
		var name_idx = (bot_id - 1) % bot_names.size()
		display_name = "%s %d" % ["Bot", bot_id]
	else:
		# Humans get name from Lobby
		for player_data in LobbyManager.get_players():
			if player_data.get("id") == my_id:
				display_name = player_data.get("name", "Player")
				break
				
	if display_name.is_empty():
		display_name = "Player %d" % my_id
	$Name.text = display_name
	
	# Character Pointer Visibility
	# Show only for our local player (not bots, not other players)
	var pointer = get_node_or_null("CharacterPointer")
	if pointer:
		if is_bot or is_in_group("Bots"):
			pointer.visible = false
		else:
			pointer.visible = is_multiplayer_authority()
	
	# Sync name to other peers if this is our local player or a bot we own
	if is_multiplayer_authority():
		rpc("sync_display_name", display_name)
	
	# Wait briefly to ensure proper scene setup and server recognition
	await get_tree().create_timer(0.5).timeout
	
	# More robust way to get the main scene
	var main_scene = get_tree().get_root().get_node_or_null("Main")
	if not main_scene:
		push_error("Main scene not found")
		return
	
	# Ensure proper initialization order
	enhanced_gridmap = get_node(enhanced_gridmap_path)
	if main_scene:
		enhanced_gridmap = main_scene.get_node("EnhancedGridMap")
		
	_init_managers()
	
	# Initialize character selection from LobbyManager
	_setup_character()
	
	# Initialize playerboard for everyone
	playerboard.resize(25)
	playerboard.fill(-1)
	
	# =========================================================================
	# BOT-SPECIFIC SETUP - BotController handles bot AI, we just disable input
	# =========================================================================
	if is_bot == true or is_in_group("Bots"):
		# Disable input processing for bots
		set_process_input(false)
		set_process_unhandled_input(false)
		
		# Set initial position for bots
		if enhanced_gridmap:
			if is_multiplayer_authority():
				current_position = _find_random_spawn_position()
				update_player_position(current_position)
				spawn_point_selected = true
				rpc("set_spawn_position", current_position)
				rpc("notify_spawn_selected", current_position)
		
		# Assign bot character (deterministic based on ID to match lobby preview)
		# Bot IDs start from 2 (host is 1)
		# Lobby slots are 0-indexed in UI loop, but bots fill empty slots.
		# Use name.to_int() because all bots have authority 1 (Server)
		var bot_id_val = name.to_int()
		var bot_characters = ["Bob", "Gatot", "Masbro", "Oldpop"]
		# Map bot ID to character index. Bot 2 -> Index 1. Bot 3 -> Index 2.
		# Formula: (bot_id - 1) % size
		var char_index = (bot_id_val - 1) % bot_characters.size()
		var bot_char_name = bot_characters[char_index]
		set_character(bot_char_name)
		if is_multiplayer_authority():
			rpc("sync_character", bot_char_name)
		
		# Sync bot status to network
		if is_multiplayer_authority():
			rpc("sync_bot_status", true)
		
		# Continue to manager initialization...
	
	# =========================================================================
	# HUMAN PLAYER SETUP
	# =========================================================================
	if enhanced_gridmap:
		enhanced_gridmap.initialize_astar()
		enhanced_gridmap.set_diagonal_movement(use_diagonal_movement)
		
		# Only set position if not using random spawn (host will assign via RPC)
		if not LobbyManager.get_randomize_spawn() and not spawn_point_selected:
			current_position = find_valid_starting_position()
			update_player_position(current_position)
	
	# Ensure proper initial positioning
	if not LobbyManager.get_randomize_spawn() and not spawn_point_selected:
		global_position = Vector3(
			current_position.x * 1 + 1 * 0.5,
			1.0,
			current_position.y * 1 + 1 * 0.5
		)
		target_visual_position = global_position
		if is_multiplayer_authority():
			rpc("sync_position", current_position)
	else:
		target_visual_position = global_position
		# If random spawn is enabled, do NOT broadcast (0,0). Wait for set_spawn_position.
		
	# Prevent visual "jump" by hiding until spawn position is confirmed
	if LobbyManager.get_randomize_spawn() and not spawn_point_selected:
		visible = false

func _init_managers():
	movement_manager = load("res://scripts/managers/player_movement_manager.gd").new()
	movement_manager.name = "MovementManager"
	add_child(movement_manager)
	movement_manager.initialize(self , enhanced_gridmap)
	
	race_manager = load("res://scripts/managers/player_race_manager.gd").new()
	race_manager.name = "RaceManager"
	add_child(race_manager)
	race_manager.initialize(self , enhanced_gridmap)
	
	# Skip InputManager for bots
	if not (is_bot or is_in_group("Bots")):
		input_manager = load("res://scripts/managers/player_input_manager.gd").new()
		input_manager.name = "InputManager"
		add_child(input_manager)
		input_manager.initialize(self , movement_manager, race_manager)
		
	playerboard_manager = load("res://scripts/managers/playerboard_manager.gd").new()
	playerboard_manager.name = "PlayerboardManager"
	add_child(playerboard_manager)
	playerboard_manager.initialize(self , enhanced_gridmap)
	
	action_manager = load("res://scripts/managers/player_action_manager.gd").new()
	action_manager.name = "ActionManager"
	add_child(action_manager)
	action_manager.initialize(self , enhanced_gridmap)
	
	special_tiles_manager = load("res://scripts/managers/special_tiles_manager.gd").new()
	special_tiles_manager.name = "SpecialTilesManager"
	add_child(special_tiles_manager)
	special_tiles_manager.initialize(self , enhanced_gridmap)
	
	powerup_manager = load("res://scripts/managers/powerup_manager.gd").new()
	powerup_manager.name = "PowerUpManager"
	add_child(powerup_manager)
	powerup_manager.initialize(self , enhanced_gridmap)

# =============================================================================
# Character Selection
# =============================================================================

func set_character(character_name: String) -> void:
	"""Show only the selected character model and hide others. Updates AnimationPlayer root."""
	# Map Lobby names to Model names
	match character_name:
		"Copper": character_name = "Oldpop"
		"Dabro": character_name = "Masbro"
		"Pip": character_name = "Bob"
		# "Gatot" matches "Gatot"
		
	if character_name not in AVAILABLE_CHARACTERS:
		push_warning("Invalid character name: %s" % character_name)
		return
	
	selected_character = character_name
	
	# Hide all character models
	if character_bob: character_bob.visible = false
	if character_masbro: character_masbro.visible = false
	if character_gatot: character_gatot.visible = false
	if character_oldpop: character_oldpop.visible = false
	
	# Show selected character and update AnimationPlayer root
	var active_character: Node3D = null
	match character_name:
		"Bob":
			if character_bob:
				character_bob.visible = true
				active_character = character_bob
		"Masbro":
			if character_masbro:
				character_masbro.visible = true
				active_character = character_masbro
		"Gatot":
			if character_gatot:
				character_gatot.visible = true
				active_character = character_gatot
		"Oldpop":
			if character_oldpop:
				character_oldpop.visible = true
				active_character = character_oldpop
	
	# Update AnimationPlayer's root node to point to active character
	if anim_player and active_character:
		anim_player.root_node = anim_player.get_path_to(active_character)
		# Start with idle animation
		play_idle_animation()

@rpc("any_peer", "call_local", "reliable")
func sync_character(character_name: String) -> void:
	"""Sync character selection across all clients."""
	set_character(character_name)

func _setup_character() -> void:
	"""Initialize character based on LobbyManager selection or defaults."""
	# Bots self-assign characters based on ID in _ready()
	# Skipping this for bots prevents race conditions or defaults overriding deterministic bot logic
	if is_bot or is_in_group("Bots"):
		return
		
	var character_name = "Masbro" # Default
	var player_authority_id = get_multiplayer_authority()
	
	# Look up character from LobbyManager for this player (works for all players)
	if LobbyManager:
		var players = LobbyManager.get_players()
		for player_data in players:
			if player_data.get("id") == player_authority_id:
				character_name = player_data.get("character", "Masbro")
				break
	
	set_character(character_name)
	
	# If this is our local player, also sync to other clients for late joiners
	if is_multiplayer_authority():
		rpc("sync_character", character_name)

# =============================================================================
# Animation Functions
# =============================================================================

# Animation speed multiplier for fast-paced gameplay
const ANIMATION_SPEED: float = 2.0

func play_walk_animation() -> void:
	"""Play walking animation at increased speed."""
	if anim_player and anim_player.has_animation("animation-pack/walk_forward"):
		anim_player.play("animation-pack/walk_forward", -1, ANIMATION_SPEED)

func play_pickup_animation() -> void:
	"""Play pickup/grab tile animation at increased speed."""
	if anim_player and anim_player.has_animation("animation-pack/take_tile_1"):
		anim_player.play("animation-pack/take_tile_1", -1, ANIMATION_SPEED)

func play_put_animation() -> void:
	"""Play put/drop tile animation at increased speed."""
	if anim_player and anim_player.has_animation("animation-pack/drop_tile_1"):
		anim_player.play("animation-pack/drop_tile_1", -1, ANIMATION_SPEED)

func play_special_animation() -> void:
	"""Play special ability animation (backflip) at increased speed."""
	if anim_player and anim_player.has_animation("animation-pack/backflip_1"):
		anim_player.play("animation-pack/backflip_1", -1, ANIMATION_SPEED * 1.5)

func play_idle_animation() -> void:
	"""Play idle animation at normal speed."""
	if anim_player and anim_player.has_animation("animation-pack/idle"):
		anim_player.play("animation-pack/idle")

# =============================================================================
# Network-Synced Animation Functions
# =============================================================================

@rpc("any_peer", "call_local", "reliable")
func sync_walk_animation() -> void:
	"""Sync walk animation across network."""
	play_walk_animation()

@rpc("any_peer", "call_local", "reliable")
func sync_pickup_animation() -> void:
	"""Sync pickup/grab animation across network."""
	play_pickup_animation()

@rpc("any_peer", "call_local", "reliable")
func sync_put_animation() -> void:
	"""Sync put/drop animation across network."""
	play_put_animation()

@rpc("any_peer", "call_local", "reliable")
func sync_special_animation() -> void:
	"""Sync special ability animation across network."""
	play_special_animation()

# =============================================================================
# Screen Shake
# =============================================================================

@rpc("any_peer", "call_local", "reliable")
func trigger_screen_shake(shake_type: String) -> void:
	# Shake disabled by user request. Camera movement now handled by CameraContextManager.
	pass

# Add function to check if position is at finish line
func is_at_finish_line() -> bool:
	return race_manager.is_at_finish_line()

# Helper function to check if a 3x3 section matches the goals pattern
# Delegated to RaceManager

# Generate full 3x3 goals for second lap
# Delegated to RaceManager

# Modify finish_race to handle lap completion
@rpc("any_peer", "reliable")
func finish_race():
	race_manager.finish_race()

# Add function to check 3x3 pattern matching anywhere in 5x5 playerboard
func check_pattern_match() -> bool:
	return race_manager.check_pattern_match()

## Add function to handle new lap
#@rpc("any_peer", "reliable")
#func start_new_lap():
	## Reset position to start
	#current_position = find_valid_starting_position()
	#update_player_position(current_position)
	#
	## Reset playerboard but keep the goals
	#playerboard.fill(-1)
	#
	## Reset can_finish flag
	#can_finish = false
	#
	## Sync with other clients
	#if is_multiplayer_authority():
		#rpc("sync_position", current_position)
		#rpc("sync_playerboard", playerboard)

# Modify start_new_lap to handle different lap goals and starting positions
@rpc("any_peer", "reliable")
func start_new_lap():
	race_manager.start_new_lap()

# Function to find valid position in finish line
# Delegated to RaceManager

# Add function to check if player can reach finish
func update_finish_availability():
	race_manager.update_finish_availability()

func unhighlight_finish_line():
	race_manager.unhighlight_finish_line()

# Add functions to handle finish line visualization
func highlight_finish_line():
	race_manager.highlight_finish_line()

func request_spawn_positions_update():
	if multiplayer.is_server():
		# Server can directly highlight available positions
		highlight_available_spawn_points()
	else:
		# Clients request an update from the server
		rpc_id(1, "server_update_spawn_positions")

# Add server-side spawn position update handler
@rpc("any_peer", "reliable")
func server_update_spawn_positions():
	if not multiplayer.is_server():
		return
		
	var sender_id = multiplayer.get_remote_sender_id()
	var occupied = get_occupied_positions()
	
	# Send the occupied positions back to the requesting client
	rpc_id(sender_id, "receive_spawn_positions_update", occupied)

# Add client-side spawn position update receiver
@rpc("authority", "reliable")
func receive_spawn_positions_update(occupied_positions: Array):
	# Update local highlight state based on received occupied positions
	for pos in highlighted_spawn_points:
		if pos in occupied_positions:
			highlighted_spawn_points.erase(pos)
			if enhanced_gridmap:
				enhanced_gridmap.set_cell_item(
					Vector3i(pos.x, 0, pos.y),
					enhanced_gridmap.normal_items[0]
				)
	
	# Now highlight available positions
	highlight_available_spawn_points()

@rpc("any_peer", "call_local", "reliable")
func sync_playerboard(new_playerboard: Array):
	"""Sync playerboard data. Called by BotController or ActionManager."""
	playerboard = new_playerboard.duplicate()
	
	# Only update UI if this is the LOCAL HUMAN PLAYER
	# Bots managed by server (ID 1) might sync here, but we must NOT update UI for them
	var is_local = name == str(multiplayer.get_unique_id())
	var is_bot_check = is_bot or is_in_group("Bots")
	
	# DEBUG: Trace why UI updates might be happening
	# print("[sync_playerboard] Player: %s (ID: %s), LocalID: %s, IsLocal: %s, IsBot: %s" % [name, get_multiplayer_authority(), multiplayer.get_unique_id(), is_local, is_bot_check])
	
	if is_local and not is_bot_check:
		var main = get_tree().get_root().get_node_or_null("Main")
		if main and main.ui_manager:
			main.ui_manager.update_playerboard_ui()
	elif is_local and is_bot_check:
		# This is a Bot running on the server (which is also the host)
		# We must NOT update the Host's UI with the Bot's data
		pass


@rpc("any_peer", "call_local")
func sync_bot_status(is_bot_status: bool):
	is_bot = is_bot_status
	if is_bot:
		add_to_group("Bots", true)
		set_process_input(false)
		set_process_unhandled_input(false)
		
		# Clear any existing highlights (if action_manager is initialized)
		if action_manager:
			action_manager.highlighted_cells.clear()
		
		# BotController already exists in scene and manages itself

@rpc("any_peer", "call_local", "reliable")
func sync_display_name(new_name: String) -> void:
	"""Sync display name across network."""
	_display_name = new_name
	if has_node("Name"):
		$Name.text = _display_name
	
@rpc("any_peer", "call_local", "reliable")
func sync_modulate(color: Color) -> void:
	"""Sync visual modulation (e.g. freeze effect) across network."""
	# Node3D doesn't have modulate. We must tint the active character meshes.
	var active_char_node = null
	
	match selected_character:
		"Bob": active_char_node = character_bob
		"Masbro": active_char_node = character_masbro
		"Gatot": active_char_node = character_gatot
		"Oldpop": active_char_node = character_oldpop
	
	if active_char_node:
		_apply_tint_recursive(active_char_node, color)

func update_rank_visuals(rank: int):
	var pos_label = get_node_or_null("Position")
	if not pos_label:
		return
		
	if rank <= 3:
		pos_label.visible = true
		if race_manager:
			pos_label.text = race_manager.get_ordinal_string(rank)
		else:
			pos_label.text = str(rank)
		
		match rank:
			1: pos_label.modulate = Color(0.85, 0.0, 0.0) # Red
			2: pos_label.modulate = Color(0.0, 0.0, 1.0) # Blue
			3: pos_label.modulate = Color(1.0, 0.9, 0.0) # Yellow
	else:
		pos_label.visible = false

func _apply_tint_recursive(node: Node, color: Color):
	if node is MeshInstance3D:
		# Simple way to tint: use material_overlay with an unshaded material if possible, 
		# or transparency. But changing albedo on shared materials affects all instances!
		# Using transparency/modulate equivalent in 3D is tricky without unique materials.
		# A common trick is to use `instance_shader_parameter` if supported, or modifying visibility range? No.
		# Best safe visual cue for "Help me create an ice effect" without shaders:
		# Set `transparency` (alpha) if we want ghost, or `material_overlay`.
		# For this quick fix, let's create a standard material overlay on the fly if needed
		# or just rely on a debug geometry.
		# Actually, geometry_instance_3d has `material_overlay`.
		# Better approach for "Freeze": Just add a visible "Ice Block" mesh to the player
		# instead of trying to tint the gltf model which might have complex materials.
		# But user asked for "modulate". The closest 3D equivalent is material_overlay with a color.
		var mat = StandardMaterial3D.new()
		mat.albedo_color = color
		mat.blend_mode = BaseMaterial3D.BLEND_MODE_MIX
		mat.cull_mode = BaseMaterial3D.CULL_DISABLED
		mat.shading_mode = BaseMaterial3D.SHADING_MODE_UNSHADED
		
		# If color is WHITE (reset), clear the overlay
		if color == Color.WHITE:
			node.material_overlay = null
			node.transparency = 0.0 # Reset
		else:
			# If color is Blue (frozen), make it semi-transparent overlay
			mat.albedo_color = color
			
			# Special Ghost Effect (Invisible Mode)
			if color.a < 1.0:
				mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
				node.transparency = 0.5 # Make base mesh transparent too if possible, depending on material
			else:
				# Frozen
				mat.albedo_color.a = 0.5 # Semi-transparent overlay
				mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA
				
			node.material_overlay = mat
			
	for child in node.get_children():
		_apply_tint_recursive(child, color)

var immunity_timer: float = 0.0

@rpc("any_peer", "call_local")
func apply_stagger(duration: float = 1.5):
	if immunity_timer > 0:
		return # Immune!
		
	if is_frozen:
		return # Already staggered
		
	is_frozen = true
	_apply_tint_recursive(self , Color.BLUE) # Visual feedback
	
	# Set immunity (3 seconds as requested)
	immunity_timer = 3.0
	
	print("Player %s staggered for %.1f seconds" % [name, duration])
	
	if is_multiplayer_authority():
		NotificationManager.send_message(self , NotificationManager.MESSAGES.CRUSHED, NotificationManager.MessageType.WARNING)
		drop_random_item()
		
		# Grant "Smashed" Bonus (1 bar, max 2)
		if powerup_manager:
			powerup_manager.acquire_smash_bonus()
	
	await get_tree().create_timer(duration).timeout
	
	is_frozen = false
	# If still immune, show immunity tint (Green?), otherwise White
	if immunity_timer > 0:
		_apply_tint_recursive(self , Color(0.5, 1.0, 0.5)) # Light Green for immunity
	else:
		_apply_tint_recursive(self , Color.WHITE) # Remove tint

@rpc("any_peer", "call_local")
func apply_slow_effect(duration: float = 3.0):
	# "area with blue like wall... Player who cross on that area will got slowed and freeze effect"
	# Visual: Blue Tint
	_apply_tint_recursive(self , Color(0.6, 0.8, 1.0)) # Icy Blue
	
	# Logic: Slow Movement speed
	if movement_manager:
		# Use 0.2 multipliers to match "slowed" request (20% speed)
		movement_manager.set_speed_multiplier(0.2)
	
	print("Player %s is slowed for %.1f seconds" % [name, duration])
		
	# Restore after duration
	# Note: If they stand in the zone, this will be re-applied constantly, resetting the visual
	await get_tree().create_timer(duration).timeout
	
	# Only restore if not re-applied recently (simple check: if still tinted?) 
	# A better way is managing a "slow_timer" but for now let's just reset if timer expires.
	# The persistent zone logic reapplies every frame, so we want this timer to be short 
	# OR we rely on the zone logic. 
	# The RPC call says "apply_slow_effect(0.5)", so it expires quickly.
	
	if movement_manager:
		movement_manager.set_speed_multiplier(1.0)
	
	if immunity_timer > 0:
		_apply_tint_recursive(self , Color(0.5, 1.0, 0.5))
	else:
		_apply_tint_recursive(self , Color.WHITE)

func playerboard_is_empty() -> bool:
	for item in playerboard:
		if item != -1:
			return false
	return true

func drop_random_item():
	if playerboard_is_empty():
		return
		
	# Find occupied slots
	var occupied_indices = []
	for i in range(playerboard.size()):
		if playerboard[i] != -1:
			occupied_indices.append(i)
			
	if occupied_indices.size() == 0:
		return
		
	# Pick random slot
	var slot_index = occupied_indices.pick_random()
	var item_id = playerboard[slot_index]
	
	# Try to find empty spot on grid near player
	var drop_pos = _find_valid_drop_position()
	
	if drop_pos != Vector2i(-1, -1):
		# Drop it
		playerboard[slot_index] = -1
		rpc("sync_playerboard", playerboard)
		
		# Sync grid item
		var cell = Vector3i(drop_pos.x, 1, drop_pos.y)
		rpc("sync_grid_item", cell.x, cell.y, cell.z, item_id)
		
		NotificationManager.send_message(self , NotificationManager.MESSAGES.DROPPED_ITEM, NotificationManager.MessageType.WARNING)
		print("Player %s dropped item %d at %s" % [name, item_id, drop_pos])


@rpc("any_peer", "call_local")
func drop_all_tiles():
	"""Drops all tiles from playerboard. Used by Super Push."""
	var dropped_count = 0
	
	for i in range(playerboard.size()):
		if playerboard[i] != -1:
			var item_id = playerboard[i]
			playerboard[i] = -1
			
			# Find a spot to drop? Or just destroy?
			# User: "drop all tiles on playerboard" -> usually implies they scatter on floor
			# But scattering 25 tiles is chaotic.
			# Let's drop a few random ones and destroy rest?
			# Or per user "spawn nearby tiles into power up" -> Maybe the dropped tiles BECOME powerups?
			# User request: "victim drops all tiles... and spawn / replace your nearby tiles into power up"
			# I will just clear the board here. Spawning is handled by spawn_powerups_around.
			dropped_count += 1
			
	if dropped_count > 0:
		rpc("sync_playerboard", playerboard)
		rpc("trigger_screen_shake", "targeted")
		NotificationManager.send_message(self , NotificationManager.MESSAGES.CRITICALLY_HIT, NotificationManager.MessageType.WARNING)
		print("Player %s dropped %d tiles due to Super Push" % [name, dropped_count])

func _find_valid_drop_position() -> Vector2i:
	# Try random adjacent cells
	var neighbors = enhanced_gridmap.get_neighbors(current_position, 0)
	neighbors.shuffle()
	
	for neighbor in neighbors:
		var pos = neighbor.position
		# Check item layer
		var item_cell = Vector3i(pos.x, 1, pos.y)
		if enhanced_gridmap.get_cell_item(item_cell) == -1:
			if not is_position_occupied(pos):
				return pos
					
	return Vector2i(-1, -1)

# =============================================================================
# Targeting Action
# =============================================================================

func attempt_target_action(target_index: int):
	# 1. Get Selected Effect from UI
	var main = get_tree().get_root().get_node_or_null("Main")
	if not main or not main.ui_manager:
		return
		
	# Quick check if UI exists and has a selection
	# We need to access the script variable 'selected_effect' from the dynamically created/loaded UI.
	# Let's assume ui_manager has a reference or we find it.
	# Based on previous step, we haven't integrated PowerUpInventoryUI into UIManager yet.
	# So we might fail here if not wired up.
	# For now, let's look for "PowerUpInventoryUI" in CanvasLayer.
	
	var inventory_ui = main.ui_manager.get_node_or_null("PowerUpInventoryUI")
	# Or check if ui_manager tracks it. 
	# Note: We haven't instantiated it yet in UIManager. We will need to do that.
	
	if not inventory_ui or inventory_ui.selected_effect == -1:
		return # No effect selected using mouse/touch first

	var effect = inventory_ui.selected_effect
	
	# 2. Find Target Player
	var player_manager = main.get_node_or_null("PlayerManager")
	if not player_manager:
		return
		
	if target_index < 0 or target_index >= player_manager.connected_peer_ids.size():
		return
		
	var target_id = player_manager.connected_peer_ids[target_index]
	var target_player = main.get_node_or_null(str(target_id))
	
	if not target_player:
		return
		
	if target_player == self and effect != 4: # 4 = INVISIBLE (Self)
		# Trying to target self with harmful effect?
		NotificationManager.send_message(self , NotificationManager.MESSAGES.CANT_TARGET_SELF, NotificationManager.MessageType.WARNING)
		return
		
	# 3. Activate Effect
	var st_manager = get_node_or_null("SpecialTilesManager")
	if st_manager:
		st_manager.activate_effect(effect, target_player)
		inventory_ui.deselect()

func activate_powerup(effect_id: int):
	var main = get_tree().get_root().get_node_or_null("Main")
	if not main or not main.ui_manager:
		return
		
	# Try to find the UI button directly if possible, or simulate the click
	# The goal is to Select it (if it requires targeting) OR Activate it (if instant)
	
	# Since PowerUpInventoryUI manages selection state, we should route through it if possible
	# or directly tell SpecialTilesManager to prepare?
	
	# Let's try to mimic the button press
	var inventory_ui = main.ui_manager.get_node_or_null("PowerUpInventoryUI") # Or wherever it lives
	if not inventory_ui:
		# Fallback: Find it in scene
		inventory_ui = main.get_node_or_null("PowerUpInventoryUI")
		
	if inventory_ui:
		# Inventory UI handles: "activate_effect(effect_id)" on click
		# Which then calls SpecialTilesManager.activate_effect
		# This handles both "Instant" effects (Speed) and "Targeting" effects (Wall)
		inventory_ui._on_btn_pressed(effect_id)
	else:
		# Fallback if UI not found
		var st_manager = get_node_or_null("SpecialTilesManager")
		if st_manager:
			st_manager.activate_effect(effect_id)


func _process(delta):
	# Failsafe: Ensure player is visible if spawn point is selected and random spawn is active
	# This handles race conditions where set_spawn_position might be called before _ready finishes hiding
	if LobbyManager.get_randomize_spawn() and spawn_point_selected and not visible:
		visible = true

	if is_multiplayer_authority():
		# Visual debugging - show display name with connection status
		$Name.text = display_name if not display_name.is_empty() else str(name)
		
		# Periodically verify our existence to others
		_verify_timer += delta
		if _verify_timer >= 3.0:
			_verify_timer = 0.0
			rpc("ping_existence")
	else:
		# Client-side visual smoothing
		# Only interpolate if NOT running a movement tween, OR if the drift is large (teleport/snap)
		if not is_player_moving:
			var dist_sq = global_position.distance_squared_to(target_visual_position)
			
			if dist_sq > 4.0: # If distance > 2.0 units (teleport/spawn), snap immediately
				global_position = target_visual_position
			elif dist_sq < 0.001: # Prevent micro-jitter
				global_position = target_visual_position
			else:
				# Interpolate towards the target position received from authority
				global_position = global_position.lerp(target_visual_position, delta * 15.0)
	
	# Delegate rotation to movement manager
	if movement_manager:
		movement_manager._process(delta)

	# Immunity Timer Logic
	if immunity_timer > 0:
		immunity_timer -= delta
		if immunity_timer <= 0:
			immunity_timer = 0
			_apply_tint_recursive(self , Color.WHITE) # Remove immunity tint

@rpc("any_peer", "call_local")
func ping_existence():
	# This just lets other clients know this player exists
	# They can check if they have this node
	pass

var last_sent_position: Vector3

func _physics_process(delta):
	if is_multiplayer_authority():
		if global_position.distance_squared_to(last_sent_position) > 0.001:
			rpc("remote_set_position", global_position)
			last_sent_position = global_position
		
		# NOTE: Finish line checking removed - game uses cycle-based goals system now

# --------------------------------------------------------------------
# Input
# --------------------------------------------------------------------

func _unhandled_input(event):
	# Handle power-up usage
	if event.is_action_pressed("use_powerup") and is_multiplayer_authority():
		if is_frozen:
			return
		if powerup_manager and powerup_manager.can_use_special():
			powerup_manager.use_special_effect()
		return
	
	if input_manager:
		input_manager.handle_unhandled_input(event)

func _on_slot_gui_input(event, slot_index, slot_ui) -> int:
	if input_manager:
		return input_manager.handle_slot_gui_input(event, slot_index, slot_ui)
	return -1

func handle_grid_click(grid_position: Vector2i):
	if input_manager:
		input_manager.handle_grid_click(grid_position)

# Modify is_position_occupied to check for selected spawn points
func is_position_occupied(pos: Vector2i) -> bool:
	for player in get_tree().get_nodes_in_group("Players"):
		if player == self:
			continue
			
		if player.spawn_point_selected and player.current_position == pos:
			return true
		
		# Check target position (where they are moving to)
		if player.is_player_moving and player.target_position == pos:
			return true
			
	return false

func find_valid_starting_position() -> Vector2i:
	if is_bot:
		return _find_random_spawn_position()
	else:
		# Auto-assign the first available spawn point for fixed spawning
		for spawn_pos in spawn_locations:
			if not is_position_occupied(spawn_pos):
				return spawn_pos
		
		# Fallback (should typically not be reached if spawn_locations > max_players)
		return Vector2i(0, 0)

# highlight_available_spawn_points is no longer needed for manual selection in this mode
func highlight_available_spawn_points():
	pass

# Add function to get all occupied positions
func get_occupied_positions() -> Array:
	var occupied = []
	for player in get_tree().get_nodes_in_group("Players"):
		if player.spawn_point_selected: # Only count players who have selected a spawn point
			occupied.append(player.current_position)
	return occupied

# Helper to find which player is at a specific position
func get_player_at_position(pos: Vector2i) -> Node3D:
	for player in get_tree().get_nodes_in_group("Players"):
		if player == self:
			continue
		
		# Check current position
		if player.current_position == pos:
			return player
			
		# Check target position if moving
		if player.is_player_moving and player.target_position == pos:
			return player
			
	return null


# Modify the select_spawn_point function to notify other clients
func select_spawn_point(spawn_pos: Vector2i) -> bool:
	if not is_multiplayer_authority() or is_bot or spawn_point_selected:
		return false
		
	if spawn_pos in highlighted_spawn_points and not is_position_occupied(spawn_pos):
		current_position = spawn_pos
		spawn_point_selected = true
		
		# Update position in the world
		position = grid_to_world(spawn_pos)
		
		# Notify all clients about the spawn selection
		rpc("notify_spawn_selected", spawn_pos)
		
		# Clear highlights locally
		clear_spawn_highlights()
		
		# Sync position with other clients
		if is_multiplayer_authority():
			rpc("sync_position", current_position)
			
		return true
	return false

func clear_spawn_highlights():
	# Clear the highlighted spawn points array
	for spawn_pos in highlighted_spawn_points:
		if enhanced_gridmap:
			# Reset the cell to its original state
			var cell_item = enhanced_gridmap.get_cell_item(Vector3i(spawn_pos.x, 1, spawn_pos.y))
			enhanced_gridmap.set_cell_item(
				Vector3i(spawn_pos.x, 0, spawn_pos.y),
				enhanced_gridmap.normal_items[0] if cell_item != -1 else -1
			)
	
	# Clear the array
	highlighted_spawn_points.clear()
	
	# Force an update of the grid visualization
	if enhanced_gridmap:
		enhanced_gridmap._update_cell_option_buttons()

func _find_random_spawn_position() -> Vector2i:
	if not enhanced_gridmap:
		print("Warning: No gridmap for random spawn")
		return Vector2i.ZERO
		
	var available_positions = []
	
	# Scan the grid for valid walkable floor tiles that are not occupied
	for x in range(enhanced_gridmap.columns):
		for z in range(enhanced_gridmap.rows):
			var pos = Vector2i(x, z)
			
			# Check Floor 0 for walkable ground (Item 0)
			var ground_item = enhanced_gridmap.get_cell_item(Vector3i(x, 0, z))
			if ground_item == 0: # Assuming 0 is walkable ground
				# Check if position is occupied by another player
				if not is_position_occupied(pos):
					available_positions.append(pos)
	
	if available_positions.size() > 0:
		var rng = RandomNumberGenerator.new()
		rng.randomize()
		return available_positions[rng.randi() % available_positions.size()]
	
	return Vector2i.ZERO

func find_random_valid_position_in_range() -> Vector2i:
	var rng = RandomNumberGenerator.new()
	rng.randomize()
	
	var valid_positions = []
	
	for x in range(max(0, current_position.x - movement_range),
				   min(enhanced_gridmap.columns, current_position.x + movement_range + 1)):
		for z in range(max(0, current_position.y - movement_range),
					  min(enhanced_gridmap.rows, current_position.y + movement_range + 1)):
			var pos = Vector2i(x, z)
			if pos != current_position and is_within_movement_range(pos):
				var cell_item = enhanced_gridmap.get_cell_item(Vector3i(x, 0, z))
				if cell_item != -1 and not (cell_item in enhanced_gridmap.non_walkable_items) and not is_position_occupied(pos):
					valid_positions.append(pos)
	
	if valid_positions.size() > 0:
		return valid_positions[rng.randi() % valid_positions.size()]
	return current_position

func raycast_to_grid(from: Vector3, to: Vector3) -> Vector2i:
	var plane = Plane(Vector3.UP, cell_offset.y)
	var intersection = plane.intersects_ray(from, to - from)
	
	if intersection:
		var adjusted_intersection = intersection - cell_offset
		var grid_position = Vector2i(
			floor(adjusted_intersection.x / cell_size.x),
			floor(adjusted_intersection.z / cell_size.z)
		)
		
		if grid_position.x >= 0 and grid_position.x < enhanced_gridmap.columns and \
		   grid_position.y >= 0 and grid_position.y < enhanced_gridmap.rows:
			return grid_position
	
	return Vector2i(-1, -1)

func is_within_movement_range(target_position: Vector2i) -> bool:
	return movement_manager.is_within_movement_range(target_position)

# -----------------------------------------------------------------
# Movement
# -----------------------------------------------------------------

func simple_move_to(grid_position: Vector2i):
	movement_manager.simple_move_to(grid_position)

func move_player_to_clicked_position(grid_position: Vector2i):
	movement_manager.move_to_clicked_position(grid_position)

@rpc("any_peer", "call_local")
func start_movement_along_path(path: Array, clear_visual: bool = true):
	is_player_moving = true
	if path.size() > 0:
		target_position = Vector2i(path[-1].x, path[-1].y)
		
	# FORCE SNAP START: Ensure we start animating from our actual grid position
	# This prevents "jumps" if the visual node drifted or was set via global_position vs position mismatch
	var start_world_pos = grid_to_world(current_position)
	if global_position.distance_squared_to(start_world_pos) > 0.001:
		global_position = start_world_pos
	
	var tween = create_tween()
	tween.set_trans(Tween.TRANS_LINEAR)
	tween.set_ease(Tween.EASE_IN_OUT)

	var step_duration = 0.25
	if movement_manager:
		step_duration = step_duration / movement_manager.speed_multiplier

	for point in path:
		# Use global_position for consistency
		tween.tween_property(self , "global_position", grid_to_world(Vector2i(point.x, point.y)), step_duration)

	tween.tween_callback(func():
		current_position = Vector2i(path[-1].x, path[-1].y)
		is_player_moving = false
		target_position = Vector2i(-1, -1)
		
		if is_carrying_tekton and is_instance_valid(carried_tekton):
			carried_tekton.current_position = current_position
		
		# FORCE SNAP: Update target visual position to the perfect grid center
		# This ensures that when interpolation resumes (in _process), it pulls to the correct spot
		target_visual_position = grid_to_world(current_position)
		
		# Check if we've reached the finish line (uses lap-aware finish locations)
		var current_finish_locs = race_manager.get_current_finish_locations() if race_manager else finish_locations
		if current_position in current_finish_locs and can_finish:
			finish_race()
		
		var main = get_tree().get_root().get_node_or_null("Main")
		
		# Clear visuals for everyone including bots
		if clear_visual:
			if enhanced_gridmap:
				enhanced_gridmap.clear_path_visualization()
		
		# Check for buffered input
		if movement_manager and movement_manager.has_method("_on_movement_finished"):
			movement_manager._on_movement_finished()
		
		# Only restore UI state if this is a human player
		if not (is_bot or is_in_group("Bots")):
			# Restore movement range highlights if it was the player's turn
			if main and main.ui_manager.current_action_state == main.ui_manager.ActionState.MOVING and is_my_turn:
				highlight_movement_range()
		
		has_moved_this_turn = path.size() <= movement_range
		
		if not (is_bot or is_in_group("Bots")):
			# Only reset to NONE if we were in MOVING state (voluntary movement).
			# If we were TARGETING/GRABBING and got pushed, preserve that state.
			if main.ui_manager.current_action_state == main.ui_manager.ActionState.MOVING:
				main.ui_manager.current_action_state = main.ui_manager.ActionState.NONE
		
		if TurnManager.turn_based_mode:
			end_turn()
		_after_action_completed()
	)

#func trigger_finish_line():
	#if not is_multiplayer_authority():
		#return
		#
	#if current_lap == 0:  # First lap
		#lap1_finishers += 1
		#race_position = lap1_finishers
		#
		## Display first lap completion message
		#var message = "Finish 1st lap on " + get_ordinal_string(race_position)
		#rpc("display_message", message)
		#print("DEBUG: Triggered first lap finish. Position: ", race_position)
		#
		## Start second lap
		#current_lap += 1
		#rpc("start_new_lap")
		#
	#elif current_lap == 1:  # Second lap
		#lap2_finishers += 1
		#race_position = lap2_finishers
		#
		## Display second lap completion message
		#var message = "Finish 2nd lap on " + get_ordinal_string(race_position)
		#rpc("display_message", message)
		#print("DEBUG: Triggered second lap finish. Position: ", race_position)
#
##func debug_finish_state():
	##print("DEBUG: Current Position: ", current_position)
	##print("DEBUG: Can Finish: ", can_finish)
	##print("DEBUG: Current Lap: ", current_lap)
	##print("DEBUG: Pattern Match: ", check_pattern_match())
	##print("DEBUG: Is at finish: ", current_position in finish_locations)

func update_player_position(grid_position: Vector2i):
	position = grid_to_world(grid_position)

func grid_to_world(grid_position: Vector2i) -> Vector3:
	var world_position = Vector3(
		grid_position.x * cell_size.x + cell_size.x * 0.5,
		cell_size.y,
		grid_position.y * cell_size.z + cell_size.z * 0.5
	) + cell_offset
	return world_position

func start_turn():
	action_points = 2
	has_moved_this_turn = false
	has_performed_action = false
	is_my_turn = true
	if is_multiplayer_authority():
		# rpc("display_message", "It's your turn!") # Handled by setter
		_after_action_completed()

func end_turn():
	is_my_turn = false
	has_moved_this_turn = false
	if is_multiplayer_authority():
		get_tree().get_root().get_node_or_null("Main").request_next_turn()

func reset_race():
	if race_manager:
		race_manager.current_lap = 0
		race_manager.race_position = 0
		race_manager.can_finish = false
		race_manager.goals = race_manager.first_lap_goals.duplicate()
		race_manager.playerboard.fill(-1)
		if is_multiplayer_authority():
			rpc("sync_goals", race_manager.goals)
			rpc("sync_playerboard", race_manager.playerboard)

# Add a static reset for new games
static func reset_race_stats():
	var race_mgr = load("res://scripts/managers/player_race_manager.gd")
	if race_mgr:
		race_mgr.lap1_finishers = 0
		race_mgr.lap2_finishers = 0

@rpc("any_peer", "call_local", "unreliable")
func remote_set_position(authority_position):
	# Don't snap directly, update target for interpolation
	target_visual_position = authority_position

@rpc("any_peer", "call_local")
func display_message(message, type: int = 0):
	# Send message to the main scene's message bar instead of player bubble
	var main = get_tree().get_root().get_node_or_null("Main")
	if main and main.has_method("add_message_to_bar"):
		var player_name_str = display_name if not display_name.is_empty() else str(name)
		main.add_message_to_bar(player_name_str, message, type)

func initialize_random_goals(_size: int, min_value: int, max_value: int, null_count: float) -> Array[int]:
	goals.clear()
	var rng = RandomNumberGenerator.new()
	rng.randomize()
	
	var result: Array[int] = []
	var null_val = 0
	var max_nulls = 3
	
	const SPECIAL_VALUES = {1: 7, 2: 8, 3: 9, 4: 10}
	
	for i in range(_size):
		if null_val < max_nulls and rng.randf() < null_count:
			result.append(-1)
			null_val += 1
		else:
			var val = rng.randi_range(min_value, max_value)
			result.append(val if not val in SPECIAL_VALUES else SPECIAL_VALUES[val])
	
	return result

# Remove this since goals are now set by main.gd
func append_random_goals():
	goals.append_array(initialize_random_goals(9, 7, 10, 1.0))
	
	if is_multiplayer_authority():
		rpc("sync_goals", goals)

func bot_try_grab_item() -> bool:
	return playerboard_manager.bot_try_grab_item()

# -----------------------------------------------------------------
# OLD GRAB Func
# -----------------------------------------------------------------
#func grab_item(grid_position: Vector2i = current_position) -> bool:
	#if is_bot:
		#return bot_try_grab_item()
		#
	#if not enhanced_gridmap or action_points <= 0:
		#return false
	#
	#var cell = Vector3i(grid_position.x, 1, grid_position.y)
	#var item = enhanced_gridmap.get_cell_item(cell)
	#
	#if grid_position != current_position:
		#var neighbors = enhanced_gridmap.get_neighbors(current_position, 0)
		#var is_adjacent = false
		#for neighbor in neighbors:
			#if neighbor.position == grid_position:
				#is_adjacent = true
				#break
		#if not is_adjacent:
			#return false
	#
	#if item == -1:
		#return false
	#
	## Bot-specific grab logic moved to bot_grab_item RPC
	#if is_in_group("Bots") or is_bot:
		#var empty_slot = playerboard.find(-1)
		#if empty_slot == -1:
			#return false
			#
		#if is_multiplayer_authority():
			#rpc("bot_grab_item", grid_position, empty_slot, cell.x, cell.y, cell.z)
		#return true
	#
	#var main = get_tree().get_root().get_node_or_null("Main")
	#if main:
		#selected_gridmap_position = grid_position
		#clear_highlights()
		#clear_playerboard_highlights()
		#
		#for i in range(playerboard.size()):
			#if playerboard[i] == -1:
				#var slot = main.playerboard_ui.get_child(i)
				#if slot.get_child_count() > 0:
					#slot.get_child(0).show()
				#highlighted_cells.append(i)
		#return true
#
	#return false
# -----------------------------------------------------------------
#func grab_item(grid_position: Vector2i = current_position) -> bool:
	#if not enhanced_gridmap or action_points <= 0:
		#return false
#
	#var cell = Vector3i(grid_position.x, 1, grid_position.y)
	#var item = enhanced_gridmap.get_cell_item(cell)
#
	## Validate adjacency (unless it's current position)
	#if grid_position != current_position:
		#var neighbors = enhanced_gridmap.get_neighbors(current_position, 0)
		#var is_adjacent = false
		#for neighbor in neighbors:
			#if neighbor.position == grid_position:
				#is_adjacent = true
				#break
		#if not is_adjacent:
			#return false
#
	#if item == -1:
		#return false
#
	## === AUTO-ARRANGE LOGIC ===
	#var target_slot = find_best_goal_slot_for_item(item)
	#if target_slot == -1:
		#return false  # no space
#
	## Perform the grab and auto-place
	#if is_multiplayer_authority():
		## Update gridmap: remove item
		#rpc("sync_grid_item", cell.x, cell.y, cell.z, -1)
		## Update playerboard
		#playerboard[target_slot] = item
		#rpc("sync_playerboard", playerboard)
		## Consume action
		#has_performed_action = true
		#consume_action_points(1)
#
		## Optional: visual feedback
		#var main = get_tree().get_root().get_node_or_null("Main")
		#if main:
			#main.update_playerboard_ui()
			#main.set_action_state(main.ActionState.NONE)
#
	#return true
# -----------------------------------------------------------------
func grab_item(grid_position: Vector2i = current_position) -> bool:
	return playerboard_manager.grab_item(grid_position)

# -----------------------------------------------------------------
# Execute Grab
# -----------------------------------------------------------------

func _execute_grab(grid_pos: Vector2i, cell: Vector3i, item_id: int):
	return playerboard_manager._execute_grab(grid_pos, cell, item_id)

# -----------------------------------------------------------------
# This function runs on the server when requested by a client
# -----------------------------------------------------------------
@rpc("any_peer", "reliable")
func request_server_grab(grid_pos: Vector2i, x: int, y: int, z: int, item_id: int):
	# 1. Only the server (peer 1) should process this
	if not multiplayer.is_server():
		return
	
	# 2. Security check: Did this request come from the actual owner of this node?
	if multiplayer.get_remote_sender_id() != get_multiplayer_authority():
		push_error("Security: Non-authority tried to grab item!")
		return
	
	# 3. Call the execution logic
	playerboard_manager._execute_grab(grid_pos, Vector3i(x, y, z), item_id)

# -----------------------------------------------------------------
# Auto-put: no manual selection needed
# Automatically puts a goal-matching tile into an adjacent (or current) empty grid cell
# -----------------------------------------------------------------
# -----------------------------------------------------------------
# Auto-put: no manual selection needed
# Automatically puts a goal-matching tile into an adjacent (or current) empty grid cell
# -----------------------------------------------------------------
func auto_put_item() -> bool:
	return playerboard_manager.auto_put_item()

# -----------------------------------------------------------------
# Force ActionState : None
# -----------------------------------------------------------------

@rpc("any_peer", "call_local", "reliable")
func force_action_state_none():
	# This is called by the server on the client to reset the UI
	if is_bot or is_in_group("Bots"):
		return
		
	var main = get_tree().get_root().get_node_or_null("Main")
	if main and main.ui_manager:
		main.ui_manager.current_action_state = main.ui_manager.ActionState.NONE
	if action_manager:
		action_manager.clear_highlights()
		action_manager.clear_playerboard_highlights()

# -----------------------------------------------------------------

@rpc("any_peer", "reliable")
func request_server_put(grid_position: Vector2i, slot_index: int, x: int, y: int, z: int, item: int):
	# This RPC should only be processed by the server
	if not multiplayer.is_server():
		return
		
	# Verify that this request came from the authority of this player
	if multiplayer.get_remote_sender_id() != get_multiplayer_authority():
		push_error("Security: Non-authority tried to put item!")
		return
	
	# Server-side validation
	var cell = Vector3i(x, y, z)
	if enhanced_gridmap.get_cell_item(cell) != -1:
		return # Cell not empty
	
	# Check if position is adjacent or current position
	if grid_position != current_position:
		var is_adjacent = false
		var neighbors = enhanced_gridmap.get_neighbors(current_position, 0)
		for neighbor in neighbors:
			if neighbor.position == grid_position:
				is_adjacent = true
				break
		if not is_adjacent:
			return # Not adjacent
	
	# Verify player has the item
	if playerboard[slot_index] != item:
		push_error("Item mismatch! Player doesn't have claimed item")
		return
		
	# Perform the put operation as the server
	rpc("sync_grid_item", x, y, z, item)
	playerboard[slot_index] = -1
	rpc("sync_playerboard", playerboard)
	
	# Update player state
	has_performed_action = true
	action_points -= 1
	selected_playerboard_slot = -1
	
	# Notify about action completion
	_after_action_completed()

# Add new RPC function to notify others about spawn selection
@rpc("any_peer", "reliable")
func notify_spawn_selected(spawn_pos: Vector2i):
	# Update local highlight state for all clients
	if spawn_pos in highlighted_spawn_points:
		highlighted_spawn_points.erase(spawn_pos)
		
	# Clear highlight for the selected position
	if enhanced_gridmap:
		enhanced_gridmap.set_cell_item(
			Vector3i(spawn_pos.x, 0, spawn_pos.y),
			enhanced_gridmap.normal_items[0]
		)

# Disabled, auto put activated
#func handle_put_action():
	#var main = get_tree().get_root().get_node_or_null("Main")
	#if not main or action_points < 1:
		#return
	#
	#if not is_bot == true:
		#clear_highlights()
		#clear_playerboard_highlights()
	#
	## Highlight non-empty slots in playerboard
	#for i in range(playerboard.size()):
		#if playerboard[i] != -1:  # Highlight occupied slots
			#var slot = main.playerboard_ui.get_child(i)
			#if slot.get_child_count() > 0:
				#slot.get_child(0).show()  # Show highlight for occupied slots
			#highlighted_cells.append(i)

func handle_playerboard_slot_selected(slot_index: int):
	playerboard_manager.handle_playerboard_slot_selected(slot_index)

# We also need to add handle_put_slot_selected:
func handle_put_slot_selected(slot_index: int):
	playerboard_manager.handle_put_slot_selected(slot_index)


func arrange_playerboard_item(slot_index: int):
	playerboard_manager.arrange_playerboard_item(slot_index)

func _on_slot_clicked(event: InputEvent, slot_index: int):
	if not event is InputEventMouseButton or is_bot == true or not event.pressed or event.button_index != MOUSE_BUTTON_LEFT:
		return
	playerboard_manager.handle_slot_clicked(slot_index)


func has_item_at_current_position() -> bool:
	var current_cell = Vector3i(current_position.x, 1, current_position.y)
	return enhanced_gridmap.get_cell_item(current_cell) != -1

func has_items_in_playerboard() -> bool:
	return playerboard.any(func(item): return item != -1)

func playerboard_is_full() -> bool:
	return playerboard.find(-1) == -1

func highlight_cells_if_authorized(cells_to_highlight: Array, item_id: int = -1):
	action_manager.highlight_cells_if_authorized(cells_to_highlight, item_id)

# Update highlight_movement_range to respect the expanded obstacle blocking
func highlight_movement_range():
	movement_manager.highlight_movement_range()

# Helper function to check if a cell can be reached given the blocked cells


# Helper function to check if a direction is diagonal


func highlight_adjacent_cells():
	movement_manager.highlight_adjacent_cells()

func highlight_empty_adjacent_cells():
	action_manager.highlight_empty_adjacent_cells()

@rpc("any_peer", "call_local")
func sync_action_points(points: int):
	action_manager.sync_action_points(points)

func highlight_random_valid_cells():
	action_manager.highlight_random_valid_cells()

func highlight_occupied_playerboard_slots():
	action_manager.highlight_occupied_playerboard_slots()

func clear_highlights():
	if action_manager:
		action_manager.clear_highlights()

func clear_playerboard_highlights():
	if action_manager:
		action_manager.clear_playerboard_highlights()

func rotate_towards_target(target_pos: Vector2i):
	movement_manager.rotate_towards_target(target_pos)

# We also need to add these supporting functions:
func select_playerboard_slot(slot_index: int):
	playerboard_manager.select_playerboard_slot(slot_index)

func deselect_playerboard_slot():
	playerboard_manager.deselect_playerboard_slot()

func target_playerboard_slot(slot_index: int):
	playerboard_manager.target_playerboard_slot(slot_index)

func untarget_playerboard_slot():
	playerboard_manager.untarget_playerboard_slot()

func can_move_to_target_playerboard_slot() -> bool:
	return playerboard_manager.can_move_to_target_playerboard_slot()

func _update_playerboard_slot_visual(slot_index: int):
	playerboard_manager._update_playerboard_slot_visual(slot_index)

func _highlight_adjacent_playerboard_slots():
	playerboard_manager._highlight_adjacent_playerboard_slots()

@rpc("any_peer", "call_local", "reliable")
func sync_rotation(new_rotation: float):
	if not is_multiplayer_authority():
		rotation.y = new_rotation
		if movement_manager:
			movement_manager.target_rotation = new_rotation

@rpc("any_peer", "call_local", "reliable")
func sync_grid_item(x: int, y: int, z: int, item: int):
	if enhanced_gridmap:
		var cell = Vector3i(x, y, z)
		
		# Log the change for debugging
		print("Setting grid item at ", cell, " to ", item, " (called by ", multiplayer.get_remote_sender_id(), ")")
		
		# Make sure we set the cell reliably
		enhanced_gridmap.set_cell_item(cell, item)
		
		# Double-check the cell was set
		var check_value = enhanced_gridmap.get_cell_item(cell)
		if check_value != item:
			push_warning("Cell item didn't update correctly! Expected " + str(item) + " but got " + str(check_value))
			# Try once more
			enhanced_gridmap.set_cell_item(cell, item)

@rpc("any_peer", "call_local")
func sync_goals(new_goals: Array):
	goals = new_goals.duplicate() # Make sure to duplicate the array
	
	# Also update race_manager's goals directly
	if race_manager:
		race_manager.goals = new_goals.duplicate()
		# Re-check finish availability with new goals
		race_manager.update_finish_availability()
	
	# Update the AllPlayerGoals UI
	var main = get_tree().get_root().get_node_or_null("Main")
	if main and main.has_method("_update_goals_ui_for_player"):
		var player_id = get_multiplayer_authority()
		main._update_goals_ui_for_player(player_id, new_goals)

@rpc("any_peer", "call_local")
func sync_second_lap_goals(new_goals: Array):
	if race_manager:
		race_manager.second_lap_goals = new_goals.duplicate()


func _after_action_completed():
	action_manager.after_action_completed()

func is_finish_position(pos: Vector2i) -> bool:
	var current_finish = race_manager.get_current_finish_locations() if race_manager else finish_locations
	return pos in current_finish

func consume_action_points(points: int):
	action_manager.consume_action_points(points)

@rpc("any_peer", "call_local")
func bot_grab_item(pos: Vector2i, slot: int, x: int, y: int, z: int):
	playerboard_manager.bot_grab_item(pos, slot, x, y, z)

@rpc("any_peer", "call_local")
func bot_put_item(pos: Vector2i, slot: int, x: int, y: int, z: int):
	playerboard_manager.bot_put_item(pos, slot, x, y, z)

@rpc("any_peer", "call_local")
func bot_arrange_item(from_slot: int, to_slot: int):
	playerboard_manager.bot_arrange_item(from_slot, to_slot)

func update_visual_position():
	# Ensure proper grid-aligned positioning
	var new_pos = Vector3(
		current_position.x * cell_size.x + cell_size.x * 0.5,
		1.0,
		current_position.y * cell_size.z + cell_size.z * 0.5
	)
	global_position = new_pos
	target_visual_position = new_pos # Snap target too
	
	if is_multiplayer_authority():
		rpc("sync_position", current_position)

@rpc("any_peer", "call_local")
func sync_position(pos: Vector2i):
	current_position = pos
	
	# If random spawn is active, receiving a position sync essentially confirms a valid spawn
	if LobbyManager.get_randomize_spawn():
		spawn_point_selected = true
		if not visible:
			visible = true

	# Always update the visual position after position sync
	var new_pos = Vector3(
		current_position.x * cell_size.x + cell_size.x * 0.5,
		cell_size.y,
		current_position.y * cell_size.z + cell_size.z * 0.5
	) + cell_offset
	
	# Only snap visual if not moving (moving players will tween to destination)
	if not is_player_moving:
		global_position = new_pos
		target_visual_position = new_pos # Reset smoothing target to prevent fighting

@rpc("any_peer", "call_local", "reliable")
func set_spawn_position(pos: Vector2i):
	"""Set spawn position - used by random spawn system."""
	current_position = pos
	spawn_point_selected = true
	# Clear any spawn highlights
	clear_spawn_highlights()
	# Update visual position
	var new_pos = Vector3(
		current_position.x * cell_size.x + cell_size.x * 0.5,
		cell_size.y,
		current_position.y * cell_size.z + cell_size.z * 0.5
	) + cell_offset
	
	print("[Player %s] set_spawn_position: Grid %s -> World %s (CellSize: %s)" % [name, pos, new_pos, cell_size])
	
	global_position = new_pos
	target_visual_position = new_pos
	
	# Reveal character now that it's in the correct position
	visible = true


@rpc("any_peer", "call_local", "reliable")
func complete_race(final_position: int):
	if race_manager:
		race_manager.on_race_completed(final_position)

# =============================================================================
# Tekton Interaction Logic
# =============================================================================

func grab_tekton():
	if not is_multiplayer_authority() or is_carrying_tekton or is_frozen:
		return
		
	# Find nearby Tekton
	var tekton = _find_nearby_tekton()
	if tekton:
		if is_multiplayer_authority():
			rpc("sync_grab_tekton", tekton.get_path())

@rpc("any_peer", "call_local", "reliable")
func sync_grab_tekton(tekton_path: NodePath):
	var tekton = get_node_or_null(tekton_path)
	if tekton:
		carried_tekton = tekton
		is_carrying_tekton = true
		tekton.set_carried(true, self )
		print("[Player %s] Grabbed Tekton %s" % [name, tekton.name])

func throw_tekton():
	if not is_multiplayer_authority() or not is_carrying_tekton or is_frozen:
		return
		
	# Determine throw direction (where player is facing)
	# NOTE: Movement manager uses atan2(x, z) which implies 0 rotation = +Z facing.
	# So we must use +basis.z (Positive Z) as forward, not standard -basis.z.
	var forward = global_transform.basis.z.normalized()
	var throw_dir = Vector2i(round(forward.x), round(forward.z))
	if throw_dir == Vector2i.ZERO: throw_dir = Vector2i(1, 0) # Fallback
	
	# Calculate distance (5 to 7 tiles)
	var rng = RandomNumberGenerator.new()
	rng.randomize()
	var distance = rng.randi_range(5, 7)
	
	var target_pos = current_position + (throw_dir * distance)
	
	# Clamp to grid bounds if possible, or just check validity
	if enhanced_gridmap:
		# Simple clamp assuming 0-based indexing and knowing size would be better, 
		# but if we don't have size, we can just raycast or check validity step by step?
		# Let's just try the target. If invalid, maybe pull back?
		# Or just let it land "off map" and handle it? 
		# Better: Clamp to grid dimensions if known. 
		# EnhancedGridMap usually has columns/rows.
		if "columns" in enhanced_gridmap and "rows" in enhanced_gridmap:
			target_pos.x = clamp(target_pos.x, 0, enhanced_gridmap.columns - 1)
			target_pos.y = clamp(target_pos.y, 0, enhanced_gridmap.rows - 1)
	
	if is_multiplayer_authority():
		rpc("sync_throw_tekton", target_pos)

@rpc("any_peer", "call_local", "reliable")
func sync_throw_tekton(target_pos: Vector2i):
	if carried_tekton:
		var tekton = carried_tekton
		carried_tekton = null
		is_carrying_tekton = false
		if tekton.has_method("set_thrown"):
			tekton.set_thrown(true)
		else:
			tekton.set_carried(false)
		
		# Visual Arc Tween
		var start_pos = tekton.global_position
		# Target world position
		var end_world_pos = Vector3(
			target_pos.x * cell_size.x + cell_size.x * 0.5,
			cell_size.y, # Floor Y
			target_pos.y * cell_size.z + cell_size.z * 0.5
		) + cell_offset
		
		var mid_pos = (start_pos + end_world_pos) / 2.0
		mid_pos.y += 4.0 # Arc height
		
		var tween = create_tween()
		tween.set_parallel(true)
		
		# Let's stick to a simple "Jump" tween:
		# 1. Move X/Z linearly to target
		tween.tween_property(tekton, "global_position:x", end_world_pos.x, 0.6).set_trans(Tween.TRANS_LINEAR)
		tween.tween_property(tekton, "global_position:z", end_world_pos.z, 0.6).set_trans(Tween.TRANS_LINEAR)
		
		# 2. Move Y up then down
		var jump_tween = create_tween()
		jump_tween.tween_property(tekton, "global_position:y", mid_pos.y, 0.3).set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_OUT)
		jump_tween.tween_property(tekton, "global_position:y", end_world_pos.y, 0.3).set_trans(Tween.TRANS_QUAD).set_ease(Tween.EASE_IN).set_delay(0.3)
		
		# Landing Callback
		jump_tween.tween_callback(func():
			tekton.current_position = target_pos
			
			# Impact Effects!
			
			# 1. Stun nearby players (Radius 2?)
			# "if there's a player around that floor they will got stunned" -> "around that floor" implies radius
			var impact_center = target_pos
			var stun_radius = 1.5 
			
			var players = get_tree().get_nodes_in_group("Players")
			print("[Throw] Checking stun impact at %s. Found %d players." % [impact_center, players.size()])
			
			for p in players:
				if p == self: continue 
				
				# Check distance
				var dist = Vector2(p.current_position.x, p.current_position.y).distance_to(Vector2(impact_center.x, impact_center.y))
				print("[Throw] Player %s at %s. Dist: %.2f (Radius: %.1f)" % [p.name, p.current_position, dist, stun_radius])
				
				if dist <= stun_radius:
					if p.has_method("apply_stagger"):
						print("[Throw] Applying stagger to %s" % p.name)
						p.apply_stagger(3.0)
						NotificationManager.send_message(self , "Stunned " + p.name + "!", NotificationManager.MessageType.WARNING)
			
			# 2. Tekton drops tiles (Spawn tiles around) AND shrinks
			if tekton.has_method("on_thrown_landing"):
				tekton.on_thrown_landing(self, 2.0)
			else:
				# Fallback
				tekton.on_hit(self , 1.0)
			
			print("[Player %s] Tekton landed at %s" % [name, target_pos])
		).set_delay(0.6)
		
		print("[Player %s] Threw Tekton to %s (Dist: %s)" % [name, target_pos, target_pos.distance_to(tekton.current_position)])

# is_attack_mode is already declared at top of file (or inherited?)
# Keeping is_knock_mode here for now or moving it up would be better, but let's just fix the error first.
var is_knock_mode: bool = false # Yellow mode for knocking Tekton

func enter_attack_mode():
	if not is_multiplayer_authority(): return
	
	is_attack_mode = true
	is_knock_mode = false # Mutually exclusive
	NotificationManager.send_message(self, "Attack Mode ACTIVATED (Red)", NotificationManager.MessageType.POWERUP)
	update_active_player_indicator()

func enter_knock_mode():
	if not is_multiplayer_authority(): return
	
	is_knock_mode = true
	is_attack_mode = false # Mutually exclusive
	NotificationManager.send_message(self, "Knock Mode ACTIVATED (Yellow)", NotificationManager.MessageType.POWERUP)
	update_active_player_indicator()

func update_active_player_indicator():
	var color = Color.WHITE
	
	if is_attack_mode:
		color = Color.RED
	elif is_knock_mode:
		color = Color.YELLOW
	
	# Apply visual tint to character model across network
	rpc("sync_modulate", color)

func knock_tekton():
	# ... legacy or helper function ...
	pass
	if not is_multiplayer_authority() or is_frozen:
		return
		
	# Requirement: Full Powerup Bar
	if not powerup_manager or not powerup_manager.can_use_special():
		NotificationManager.send_message(self , "Need Full Boost to Knock!", NotificationManager.MessageType.WARNING)
		return
		
	var tekton = _find_nearby_tekton()
	if tekton:
		# Consume Boost
		powerup_manager.consume_boost(100.0)
		
		if is_multiplayer_authority():
			rpc("sync_knock_tekton", tekton.get_path())
			
		# Reset Knock Mode after successful hit
		is_knock_mode = false
		NotificationManager.send_message(self, "Knock Successful!", NotificationManager.MessageType.POWERUP)
		update_active_player_indicator()

@rpc("any_peer", "call_local", "reliable")
func sync_knock_tekton(tekton_path: NodePath):
	var tekton = get_node_or_null(tekton_path)
	if tekton:
		# Intensity 2.0 for knock (drops 200% tiles) + Shrink/Recover
		# Use on_thrown_landing to trigger shrink animation and floor freeze
		tekton.on_thrown_landing(self, 2.0)
		print("[Player %s] Knocked Tekton %s" % [name, tekton.name])
		
		# Visual feedback (Juice)
		if is_multiplayer_authority():
			rpc("trigger_screen_shake", "heavy")

func _find_nearby_tekton() -> Node3D: # Find closest Tekton
	var closest_tekton = null
	var min_dist = 9999.0
	
	var tektons = get_tree().get_nodes_in_group("Tektons")
	for t in tektons:
		if t.is_carried: continue
		if t.get("is_recovering"): continue # Cannot grab recovering/shrunk Tekton
		
		# Check adjacency (or same tile)
		# Assuming is_adjacent_or_same is a helper function that checks if two Vector2i are adjacent or the same.
		# For example: (pos1 - pos2).length_squared() <= 2 (for adjacent or same tile)
		var dist_grid = (t.current_position - current_position).length()
		if dist_grid <= 1.5: # Adjacent (1.0 or 1.41) or same tile (0.0)
			var dist = global_position.distance_to(t.global_position)
			if dist < min_dist:
				min_dist = dist
				closest_tekton = t
	return closest_tekton