extends StaticBody2D

@export_enum("GateDoor", "KeyDoor", "StoneDoor") var type: String = "StoneDoor"

@export_enum("Left", "Up", "Right", "Down") var direction: String = "Up"
#KeyDoors should always be closed at start
#StoneDoor and GateDoor CAN be opened in start, and become closed when entering it's room
#Then you must press a switch in the room or maybe you need to defeat all enemies in the room
@export var is_closed: bool = true 
var is_closing:bool = false
var is_opening:bool = false
var time_to_move:float = 0.2
var move_timer:float = 0.0
var animation_start_position: Vector2 = Vector2.ZERO  # Position when animation started

var closed_position: Vector2 = Vector2.ZERO  # Position when door is closed (local)
var open_offset: Vector2 = Vector2.ZERO  # Offset from closed to open position (local)

# Room and puzzle state
var blocking_room: Dictionary = {}  # Room this door blocks (the room you enter INTO)
var room1: Dictionary = {}  # First room connected by this door (room you leave FROM)
var room2: Dictionary = {}  # Second room connected by this door (room you enter INTO - the blocking_room)
var switch_room: Dictionary = {}  # Room where the switch is located (before the door)
var room_trigger_area: Area2D = null  # Reference to room trigger area for the blocking room
var puzzle_solved: bool = false  # True when room puzzle is solved
var enemies_defeated: bool = false  # True when all enemies in room are defeated
var switches_activated: bool = false  # True when required switches are activated

# Key door state
var key_used: bool = false  # True when key has been used
var key_indicator: Sprite2D = null  # Visual indicator showing key above door

# Floor switches this door is connected to
var connected_switches: Array = []  # Array of floor switch nodes
var requires_enemies: bool = false  # True if door requires defeating enemies to open
var requires_switch: bool = false  # True if door requires activating switches to open

# Smoke puff scene for StoneDoor effects
var smoke_puff_scene = preload("res://scenes/smoke_puff.tscn")

# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	# Set texture based on door type
	_update_door_texture()
	
	# Rotate door first based on direction (original order)
	if direction == "Left":
		self.rotate(-PI/2)
	elif direction == "Right":
		self.rotate(PI/2)
	elif direction == "Down":
		self.rotate(PI)
		
	# Calculate open offset based on direction (in WORLD space)
	# NEW RULES: 
	# - Open state: door is at specific tile (UP:tile2, RIGHT:tile4, DOWN:tile2, LEFT:tile3)
	# - Closed state: door moves 16 pixels offset from open position
	#   - UP: closed = open + (0, 16) = 16px down (from tile 2 to tile 5)
	#   - RIGHT: closed = open + (-16, 0) = 16px left (from tile 4 to tile 3)
	#   - DOWN: closed = open + (0, 16) = 16px down (from tile 2 to tile 5)
	#   - LEFT: closed = open + (16, 0) = 16px right (from tile 3 to tile 4)
	var open_amount = 16.0
	open_offset = Vector2.ZERO
	$TeleporterIntoClosedRoom.is_enabled = false # disable initially (only enable on closed!)
	
	if direction == "Up":
		# Door on top wall: closed state is 16px DOWN from open state
		# So open_offset is positive Y (door moves down when closing, so open is up)
		# Actually wait - if closed is 16px down from open, then open is 16px up from closed
		# So open_offset should be negative Y (open position is above closed position)
		open_offset = Vector2(0, -open_amount)  # Open is 16px UP from closed
	elif direction == "Down":
		# Door on bottom wall: 
		# For StoneDoor/GateDoor: open is at (col 1, row 1), closed is at (col 1, row 0)
		#   So closed is 16px UP from open, open_offset = (0, -16) means open is 16px DOWN from closed
		# For KeyDoor: closed is at (col 1, row 0), open is at (col 1, row 1)
		#   So open is 16px DOWN from closed, open_offset = (0, 16)
		# NOTE: This is recalculated in _ready_after_setup() based on door type
		open_offset = Vector2(0, -open_amount)  # For StoneDoor/GateDoor: open is 16px DOWN from closed
	elif direction == "Left":
		# Door on left wall: closed state is 16px RIGHT from open state
		# So open_offset is positive X (door moves right when closing, so open is left)
		# Actually wait - if closed is 16px right from open, then open is 16px left from closed
		# So open_offset should be negative X (open position is left of closed position)
		open_offset = Vector2(-open_amount, 0)  # Open is 16px LEFT from closed
	elif direction == "Right":
		# Door on right wall: closed state is 16px LEFT from open state
		# So open_offset is negative X (door moves left when closing, so open is right)
		# Actually wait - if closed is 16px left from open, then open is 16px right from closed
		# So open_offset should be positive X (open position is right of closed position)
		open_offset = Vector2(open_amount, 0)  # Open is 16px RIGHT from closed
	
	# Note: closed_position will be set in _ready_after_setup after door is positioned
	# For now, just initialize it
	closed_position = position
	
	# Connect KeyInteractionArea signal
	var key_area = get_node_or_null("KeyInteractionArea")
	if key_area:
		key_area.body_entered.connect(_on_key_interaction_area_body_entered)
	
	# Call setup after a frame to ensure everything is ready
	call_deferred("_ready_after_setup")
	
	# Ensure door_index meta is set if name follows BlockingDoor_<index>
	if name.begins_with("BlockingDoor_") and not has_meta("door_index"):
		var index_str = name.substr(13)
		if index_str.is_valid_int():
			set_meta("door_index", index_str.to_int())

func _update_door_texture():
	# Update door texture based on door type
	var sprite = get_node_or_null("Sprite2D")
	if not sprite:
		return
	
	match type:
		"KeyDoor":
			var locked_texture = load("res://assets/gfx/door_locked.png")
			if locked_texture:
				sprite.texture = locked_texture
				LogManager.log("Door: Set KeyDoor texture to door_locked.png", LogManager.CATEGORY_DOOR)
			else:
				LogManager.log_error("Door: Could not load door_locked.png texture!", LogManager.CATEGORY_DOOR)
		"GateDoor":
			var gate_texture = load("res://assets/gfx/door_gate.png")
			if gate_texture:
				sprite.texture = gate_texture
				LogManager.log("Door: Set GateDoor texture to door_gate.png", LogManager.CATEGORY_DOOR)
			else:
				LogManager.log_error("Door: Could not load door_gate.png texture!", LogManager.CATEGORY_DOOR)
		"StoneDoor":
			# Use door_barred.png for stone doors
			var barred_texture = load("res://assets/gfx/door_barred.png")
			if barred_texture:
				sprite.texture = barred_texture
				LogManager.log("Door: Set StoneDoor texture to door_barred.png", LogManager.CATEGORY_DOOR)
			else:
				LogManager.log_error("Door: Could not load door_barred.png texture!", LogManager.CATEGORY_DOOR)

# Called every frame. 'delta' is the elapsed time since the previous frame.
func _process(delta: float) -> void:
	# Handle door opening/closing animation
	if is_opening or is_closing:
		# Safety check: ensure closed_position is valid before animating
		if closed_position == Vector2.ZERO:
			LogManager.log_error("Door: ERROR - closed_position is zero during animation! Resetting...", LogManager.CATEGORY_DOOR)
			closed_position = position - open_offset if is_opening else position
			is_opening = false
			is_closing = false
			move_timer = 0.0
			# Only update collision for StoneDoor and GateDoor (KeyDoors handle their own state)
			if type == "StoneDoor" or type == "GateDoor":
				_update_collision_based_on_position()
			return
		
		move_timer += delta
		var progress = clamp(move_timer / time_to_move, 0.0, 1.0)
		
		if is_opening:
			# Interpolate from closed to open position
			# Start at closed_position (or animation_start_position if set), end at closed_position + open_offset (moving AWAY from closed position)
			var start_pos = animation_start_position if animation_start_position != Vector2.ZERO else closed_position
			var target_pos = closed_position + open_offset
			position = start_pos.lerp(target_pos, progress)
			global_position = position  # Also update global position during animation
			# Debug: log for KeyDoors to verify movement
			if type == "KeyDoor" and move_timer < 0.1:  # Only log once at start of animation
				LogManager.log("Door: KeyDoor opening animation - start: " + str(start_pos) + ", target: " + str(target_pos) + ", offset: " + str(open_offset) + ", direction: " + str(direction), LogManager.CATEGORY_DOOR)
			
			# For KeyDoors: disable collision as soon as opening starts (allow passage immediately)
			# For StoneDoor/GateDoor: update collision based on position
			if type == "KeyDoor":
				# KeyDoors: disable collision immediately when opening starts
				if get_collision_layer_value(7):
					set_collision_layer_value(7, false)
			elif type == "StoneDoor" or type == "GateDoor":
				# Update collision based on distance to closed position (disable when moving away)
				var dist_to_closed = position.distance_to(closed_position)
				if dist_to_closed > 5.0:
					# Moving away from closed position - disable collision
					if get_collision_layer_value(7):
						set_collision_layer_value(7, false)
				else:
					# Still near closed position - keep collision enabled
					if not get_collision_layer_value(7):
						set_collision_layer_value(7, true)
		elif is_closing:
			# Interpolate from open to closed position
			# NOTE: KeyDoors should NEVER close (only open with key)
			# CRITICAL: Use stored starting position (set when animation started in _close())
			# If animation_start_position wasn't set, calculate open position from closed_position + open_offset
			var start_pos = animation_start_position if animation_start_position != Vector2.ZERO else (closed_position + open_offset)
			position = start_pos.lerp(closed_position, progress)
			global_position = position  # Also update global position during animation
			
			# Update collision for StoneDoor/GateDoor only
			if type == "StoneDoor" or type == "GateDoor":
				# Update collision based on distance to closed position (enable when approaching closed)
				var dist_to_closed = position.distance_to(closed_position)
				if dist_to_closed <= 5.0:
					# At or near closed position - enable collision
					if not get_collision_layer_value(7):
						set_collision_layer_value(7, true)
				else:
					# Still away from closed position - keep collision disabled
					if get_collision_layer_value(7):
						set_collision_layer_value(7, false)
		
		if move_timer >= time_to_move:
			# Animation complete
			if is_opening:
				is_closed = false
				# Move door to open position (away from closed position)
				var open_position = closed_position + open_offset
				position = open_position
				global_position = open_position  # Also set global position
				# When moved from closed position (open), collision should be DISABLED
				set_collision_layer_value(7, false)
				var key_used_str = " (key_used=" + str(key_used) + ")" if type == "KeyDoor" else ""
				LogManager.log("Door: Opening animation complete - moved to open position: " + str(open_position) + " (closed: " + str(closed_position) + ", offset: " + str(open_offset) + ") - collision DISABLED" + key_used_str, LogManager.CATEGORY_DOOR)
				
				# CRITICAL: For KeyDoors, ensure key_used is true after animation completes
				# This prevents the door from being reset to closed in _process()
				if type == "KeyDoor":
					key_used = true
				
				# Spawn smoke puffs when StoneDoor finishes opening (1-2 puffs)
				if type == "StoneDoor":
					_spawn_smoke_puffs_on_open()
				
				# Animation finished, reset flags
				is_opening = false
				is_closing = false
				move_timer = 0.0
				animation_start_position = Vector2.ZERO  # Reset animation start position
			else:
				# Closing animation complete
				is_closed = true
				position = closed_position
				global_position = closed_position  # Also set global position
				# When at closed position, collision should be ENABLED
				set_collision_layer_value(7, true)
				LogManager.log("Door: Closing animation complete - moved to closed position: " + str(closed_position) + " - collision ENABLED", LogManager.CATEGORY_DOOR)
				
				# Spawn smoke puffs when StoneDoor finishes closing (1-3 puffs)
				if type == "StoneDoor":
					_spawn_smoke_puffs_on_close()
				
				# Animation finished, reset flags
				is_opening = false
				is_closing = false
				move_timer = 0.0
				animation_start_position = Vector2.ZERO  # Reset animation start position
				# Now that door has finished closing, check if puzzle is solved (to open it immediately if already solved)
				if type == "StoneDoor" or type == "GateDoor":
					_check_puzzle_state()
	
	# Update collision based on actual position (safety check in case position was changed externally)
	# CRITICAL: KeyDoors should NEVER have their position/state changed automatically!
	# Only update if not currently animating (to avoid interfering with animation)
	# Only update for StoneDoor and GateDoor (NOT KeyDoors)
	# IMPORTANT: Only update collision, don't change position - that could interfere with initial setup
	if not is_opening and not is_closing and (type == "StoneDoor" or type == "GateDoor"):
		# Only update collision based on position, don't change position or is_closed flag
		# Position and is_closed should only be changed by explicit _open()/_close() calls or animation
		var distance_to_closed = position.distance_to(closed_position) if closed_position != Vector2.ZERO else 999.0
		if distance_to_closed <= 1.0:
			# At closed position - collision should be ENABLED
			if not get_collision_layer_value(7):
				set_collision_layer_value(7, true)
		else:
			# Away from closed position (open) - collision should be DISABLED
			if get_collision_layer_value(7):
				set_collision_layer_value(7, false)
	
	# For StoneDoor and GateDoor, periodically check puzzle state (only if door is closed and puzzle not solved)
	# CRITICAL: Only check puzzle state if door has puzzle elements (switches or enemies)
	# If door has no puzzle elements, it should never open
	# Check every 10 frames (0.16 seconds at 60fps) to reduce performance impact
	var check_puzzle_timer = Engine.get_process_frames() % 10
	if check_puzzle_timer == 0 and (type == "StoneDoor" or type == "GateDoor") and is_closed and not puzzle_solved:
		# Check if door requires enemies or switches
		if requires_enemies or requires_switch:
			_check_puzzle_state()
	
	# For KeyDoors, ensure they stay at closed position if not opened
	# KeyDoors should NEVER move unless explicitly opened with a key
	if type == "KeyDoor" and not is_opening and not is_closing and not key_used:
		# Ensure KeyDoor is at closed position and has collision enabled
		if closed_position != Vector2.ZERO:
			# Snap to closed position if somehow moved (shouldn't happen, but safety check)
			var distance_to_closed = position.distance_to(closed_position)
			if distance_to_closed > 1.0:
				LogManager.log("Door: KeyDoor was moved incorrectly! Resetting to closed position.", LogManager.CATEGORY_DOOR)
				position = closed_position
				is_closed = true
				set_collision_layer_value(7, true)

func _update_collision_based_on_position():
	# Update collision based on whether door is at closed position or moved away
	# CRITICAL: This function should NEVER be called for KeyDoors!
	# Only for StoneDoor and GateDoor
	# CRITICAL: This function ONLY updates collision, it does NOT change position or is_closed flag
	# Position and is_closed should only be changed by explicit _open()/_close() calls or animation
	if type == "KeyDoor":
		return  # Don't update KeyDoors - they handle their own state
	
	# Only update collision, don't change position or is_closed flag
	var distance_to_closed = position.distance_to(closed_position) if closed_position != Vector2.ZERO else 999.0
	var distance_threshold = 1.0  # Consider "at closed position" if within 1 pixel
	
	if distance_to_closed <= distance_threshold:
		# Door is at closed position - collision should be ENABLED
		if not get_collision_layer_value(7):
			set_collision_layer_value(7, true)
	else:
		# Door is moved away from closed position (open) - collision should be DISABLED
		if get_collision_layer_value(7):
			set_collision_layer_value(7, false)

func _open():
	# Only open on server/authority in multiplayer, then sync to clients
	if multiplayer.has_multiplayer_peer() and not multiplayer.is_server():
		return  # Clients wait for RPC
	
	$TeleporterIntoClosedRoom.is_enabled = false
	# CRITICAL: For KeyDoors, ensure they start from closed position before opening
	# KeyDoors should ALWAYS start from closed position when opening (never from open position)
	if type == "KeyDoor":
		# KeyDoors should always be at closed position when opening starts
		# If somehow moved, reset to closed position first
		if closed_position != Vector2.ZERO:
			# Reset to closed position to ensure animation starts from correct position
			position = closed_position
			global_position = closed_position
			is_closed = true
			set_collision_layer_value(7, true)  # Collision enabled at closed position
			LogManager.log("Door: KeyDoor _open() called - reset to closed position " + str(closed_position) + " before opening", LogManager.CATEGORY_DOOR)
		else:
			LogManager.log_error("Door: KeyDoor _open() called but closed_position is zero!", LogManager.CATEGORY_DOOR)
			return
		$SfxOpenKeyDoor.play()
	else:
		# StoneDoor/GateDoor: Only open if door is currently closed
		var distance_to_closed = position.distance_to(closed_position) if closed_position != Vector2.ZERO else 999.0
		var is_actually_open = distance_to_closed > 5.0
		
		if is_actually_open:
			# Door is already open - don't do anything
			LogManager.log("Door: _open() called but door is already open! Position: " + str(position) + ", closed: " + str(closed_position) + ", distance: " + str(distance_to_closed), LogManager.CATEGORY_DOOR)
			# Ensure door is at open position and collision is disabled
			var open_pos = closed_position + open_offset
			position = open_pos
			global_position = open_pos
			is_closed = false
			set_collision_layer_value(7, false)
			return  # Don't start animation
		
		# Door is closed - ensure it's at closed position before opening
		if closed_position != Vector2.ZERO:
			position = closed_position
			global_position = closed_position
			is_closed = true
			set_collision_layer_value(7, true)
			LogManager.log("Door: StoneDoor/GateDoor _open() called - ensuring door is at closed position " + str(closed_position) + " before opening", LogManager.CATEGORY_DOOR)
		else:
			LogManager.log_error("Door: StoneDoor/GateDoor _open() called but closed_position is zero!", LogManager.CATEGORY_DOOR)
			return
		if type == "GateDoor":
			$SfxOpenGateDoor.play()
		else:
			$SfxOpenStoneDoor.play()
	
	# CRITICAL: Store starting position for animation (should be closed_position)
	animation_start_position = position
	LogManager.log("Door: Starting open animation from " + str(animation_start_position) + " to " + str(closed_position + open_offset) + " (offset: " + str(open_offset) + ")", LogManager.CATEGORY_DOOR)
	is_opening = true
	is_closing = false
	move_timer = 0.0
	
	# Sync door opening to clients in multiplayer
	if multiplayer.has_multiplayer_peer() and multiplayer.is_server() and is_inside_tree():
		var game_world = get_tree().get_first_node_in_group("game_world")
		if game_world and game_world.has_method("_rpc_to_ready_peers"):
			game_world._rpc_to_ready_peers("_sync_door_open_by_name", [name])
			# Also sync puzzle_solved state
			game_world._rpc_to_ready_peers("_sync_door_puzzle_solved_by_name", [name, puzzle_solved])
		
		# Track door state for syncing to new clients
		if game_world:
			game_world.door_states[name] = {
				"is_closed": false,
				"puzzle_solved": puzzle_solved,
				"key_used": key_used if "key_used" in self else false,
				"position": position,
				"closed_position": closed_position,
				"open_offset": open_offset
			}
	
func _close():
	# Only close on server/authority in multiplayer, then sync to clients
	if multiplayer.has_multiplayer_peer() and not multiplayer.is_server():
		return  # Clients wait for RPC
	
	# CRITICAL: KeyDoors should NEVER be closed (they only open with a key and stay open)
	if type == "KeyDoor":
		LogManager.log_error("Door: ERROR - _close() called on KeyDoor! KeyDoors should never be closed!", LogManager.CATEGORY_DOOR)
		return
	
	# Ensure closed_position is valid before closing
	if closed_position == Vector2.ZERO:
		# If closed_position wasn't set correctly, use current position
		closed_position = position
		LogManager.log("Door: WARNING - closed_position was zero, using current position: " + str(closed_position), LogManager.CATEGORY_DOOR)
	
	# Check both flag and actual position to determine door state
	var distance_to_closed = position.distance_to(closed_position) if closed_position != Vector2.ZERO else 999.0
	var is_actually_at_closed = distance_to_closed < 5.0  # Within 5 pixels of closed position
	
	LogManager.log("Door: _close() called - is_closed: " + str(is_closed) + ", is_actually_at_closed: " + str(is_actually_at_closed) + ", position: " + str(position) + ", closed: " + str(closed_position) + ", distance: " + str(distance_to_closed), LogManager.CATEGORY_DOOR)
	
	# If door is already at closed position (both visually and by flag), don't do anything
	if is_closed and is_actually_at_closed and not is_opening and not is_closing:
		LogManager.log("Door: Already closed (both flag and position match), not closing again", LogManager.CATEGORY_DOOR)
		return  # Already closed, don't do anything
	
	# CRITICAL: If door is at closed position but flag says open, just fix the state - don't animate
	if is_actually_at_closed and not is_closed:
		# Door is visually at closed position but flag says open - fix state only
		LogManager.log("Door: Door is at closed position but flag says open! Fixing state only (no animation)", LogManager.CATEGORY_DOOR)
		position = closed_position  # Ensure exact position
		is_closed = true
		set_collision_layer_value(7, true)
		return  # Don't start animation
	
	# Door is actually open (position is away from closed position) - start closing animation
	# CRITICAL: Store starting position BEFORE starting animation
	# Calculate expected open position (closed_position + open_offset)
	var expected_open_pos = closed_position + open_offset
	var distance_to_open = position.distance_to(expected_open_pos)
	
	# Use current position as start (it should already be at open position)
	# If door is significantly away from expected open position, snap to open position first
	if distance_to_open > 10.0:
		# Door is very far from expected open position - reset to open position first
		LogManager.log("Door: WARNING - Door is far from expected open position! Resetting to open: " + str(expected_open_pos) + " (was at: " + str(position) + ", distance: " + str(distance_to_open) + ")", LogManager.CATEGORY_DOOR)
		animation_start_position = expected_open_pos
		position = expected_open_pos
		global_position = expected_open_pos
		is_closed = false
		set_collision_layer_value(7, false)
	else:
		# Door is at or near open position - use current position as start
		animation_start_position = position
	
	LogManager.log("Door: Starting close animation from " + str(animation_start_position) + " to " + str(closed_position) + " (offset: " + str(open_offset) + ")", LogManager.CATEGORY_DOOR)
	if type == "GateDoor":
		$SfxCloseGateDoor.play()
	else:
		$SfxDoorCloses.play()
	is_opening = false
	is_closing = true
	move_timer = 0.0
	$TeleporterIntoClosedRoom.is_enabled = true
	
	# Sync door closing to clients in multiplayer
	if multiplayer.has_multiplayer_peer() and multiplayer.is_server() and is_inside_tree():
		var game_world = get_tree().get_first_node_in_group("game_world")
		if game_world and game_world.has_method("_rpc_to_ready_peers"):
			game_world._rpc_to_ready_peers("_sync_door_close_by_name", [name])
		
		# Track door state for syncing to new clients
		if game_world:
			game_world.door_states[name] = {
				"is_closed": true,
				"puzzle_solved": puzzle_solved,
				"key_used": key_used if "key_used" in self else false,
				"position": position,
				"closed_position": closed_position,
				"open_offset": open_offset
			}

func _ready_after_setup():
	# Called after door is fully set up with room references and positioned
	# NEW LOGIC: Door is positioned at OPEN tile position by game_world
	# The position set by game_world is the OPEN position (initial state for blocking doors)
	var open_position = position  # Current position is the OPEN position (from tile coordinates)
	
	LogManager.log("Door: _ready_after_setup() called - type: " + str(type) + ", direction: " + str(direction) + ", is_closed: " + str(is_closed) + ", open_position: " + str(open_position), LogManager.CATEGORY_DOOR)
	
	# CRITICAL: Calculate closed position based on direction
	# For StoneDoor/GateDoor: They start OPEN, then CLOSE when entering room
	# For KeyDoor: They start CLOSED, then OPEN when key is used
	# - UP: closed = open + (0, 16) = 16px down (from tile 2 to tile 5)
	# - RIGHT: closed = open + (-16, 0) = 16px left (from tile 4 to tile 3)
	# - DOWN: For StoneDoor/GateDoor: closed = open + (0, -16) = 16px UP (from row 1 to row 0)
	#         For KeyDoor: open = closed + (0, 16) = 16px DOWN (from row 0 to row 1)
	# - LEFT: closed = open + (16, 0) = 16px right (from tile 3 to tile 4)
	var closed_offset = Vector2.ZERO
	match direction:
		"Up":
			closed_offset = Vector2(0, 16)  # Closed is 16px DOWN from open
		"Down":
			# CRITICAL: For StoneDoor/GateDoor, they start OPEN at (col 1, row 1) and close to (col 1, row 0)
			# So closed is 16px UP from open (negative Y)
			# For KeyDoor, they start CLOSED at (col 1, row 0) and open to (col 1, row 1)
			# But KeyDoor logic is handled separately in _ready_after_setup()
			if type == "KeyDoor":
				# KeyDoor: closed is at row 0, open is at row 1 (16px down)
				# But we calculate from open_position, so this won't be used for KeyDoor
				closed_offset = Vector2(0, -16)  # Won't be used - KeyDoor uses different logic
			else:
				# StoneDoor/GateDoor: open is at row 1, closed is at row 0 (16px up)
				closed_offset = Vector2(0, -16)  # Closed is 16px UP from open
		"Left":
			closed_offset = Vector2(16, 0)  # Closed is 16px RIGHT from open
		"Right":
			closed_offset = Vector2(-16, 0)  # Closed is 16px LEFT from open
	
	closed_position = open_position + closed_offset
	
	# Update open_offset for animation logic (offset from closed to open)
	# This is used when opening from closed position
	open_offset = -closed_offset  # open_offset = (0, -16) means open is 16px up from closed
	
	LogManager.log("Door: Calculated positions - open: " + str(open_position) + ", closed: " + str(closed_position) + ", closed_offset: " + str(closed_offset) + ", open_offset: " + str(open_offset), LogManager.CATEGORY_DOOR)
	
	# CRITICAL: KeyDoors should ALWAYS start closed, regardless of is_closed value
	# KeyDoors should NEVER be moved until opened with a key
	# For KeyDoors: game_world positions them at CLOSED position (row 0 for Down doors)
	# When opened, they move to OPEN position (row 1 for Down doors) - 16px DOWN
	if type == "KeyDoor":
		# For KeyDoors, the position from game_world is the CLOSED position
		# Calculate open position from closed position
		var keydoor_closed_position = position  # Current position is CLOSED (from game_world)
		
		# Calculate open position based on direction
		var keydoor_open_offset = Vector2.ZERO
		match direction:
			"Up":
				keydoor_open_offset = Vector2(0, -16)  # Open is 16px UP from closed
			"Down":
				keydoor_open_offset = Vector2(0, 16)  # Open is 16px DOWN from closed (row 0 to row 1)
			"Left":
				keydoor_open_offset = Vector2(-16, 0)  # Open is 16px LEFT from closed
			"Right":
				keydoor_open_offset = Vector2(16, 0)  # Open is 16px RIGHT from closed
		
		# Set positions correctly for KeyDoor
		closed_position = keydoor_closed_position  # Closed is where game_world placed it
		open_offset = keydoor_open_offset  # Offset to move from closed to open
		
		# KeyDoor starts CLOSED
		is_closed = true
		position = closed_position
		global_position = closed_position
		set_collision_layer_value(7, true)  # Collision enabled when closed
		LogManager.log("Door: KeyDoor starting CLOSED at position " + str(position) + " (direction: " + str(direction) + "), will open to " + str(closed_position + open_offset) + " - collision ENABLED", LogManager.CATEGORY_DOOR)
		# Create key indicator sprite for KeyDoor
		_create_key_indicator()
		return  # Exit early for KeyDoors
	elif is_closed:
		# StoneDoor/GateDoor starting closed (shouldn't happen for blocking doors, but handle it)
		position = closed_position
		global_position = closed_position
		is_closed = true  # Ensure state matches position
		set_collision_layer_value(7, true)
		LogManager.log("Door: Starting CLOSED at position " + str(position) + " (type: " + str(type) + ", direction: " + str(direction) + ") - collision ENABLED", LogManager.CATEGORY_DOOR)
	else:
		# StoneDoor/GateDoor starting OPEN (default for blocking doors)
		# CRITICAL: Door MUST start at open position (which is where game_world placed it)
		# Ensure position is EXACTLY at open_position (don't assume game_world set it correctly)
		if position.distance_to(open_position) > 1.0:
			# Position doesn't match open_position - force it to open position
			LogManager.log("Door: WARNING - Position doesn't match open_position! Forcing to open: " + str(open_position) + " (was: " + str(position) + ")", LogManager.CATEGORY_DOOR)
			position = open_position
		
		global_position = position  # Ensure global_position matches position
		is_closed = false  # CRITICAL: State MUST be false (open) when at open position
		set_collision_layer_value(7, false)  # CRITICAL: Collision MUST be DISABLED when open
		LogManager.log("Door: Starting OPEN at position " + str(position) + " (closed: " + str(closed_position) + ", open: " + str(open_position) + ", open_offset: " + str(open_offset) + ", type: " + str(type) + ", direction: " + str(direction) + ") - collision DISABLED, is_closed: " + str(is_closed), LogManager.CATEGORY_DOOR)
		
		# CRITICAL: Verify the door is actually at open position after setting it
		var actual_distance = position.distance_to(closed_position)
		var expected_distance = 16.0  # Should be 16 pixels away
		if abs(actual_distance - expected_distance) > 2.0:
			LogManager.log_error("Door: ERROR - Door open/closed distance is wrong! Position: " + str(position) + ", closed: " + str(closed_position) + ", distance: " + str(actual_distance) + " (expected: " + str(expected_distance) + ")", LogManager.CATEGORY_DOOR)
			# Force it to correct open position
			position = open_position
			global_position = open_position
			is_closed = false  # CRITICAL: Ensure state is false when at open position
			set_collision_layer_value(7, false)
			LogManager.log("Door: FORCED door to open position: " + str(position) + " (distance to closed: " + str(position.distance_to(closed_position)) + ", is_closed: " + str(is_closed) + ")", LogManager.CATEGORY_DOOR)
		
		# FINAL VERIFICATION: Double-check state matches position
		var distance_to_closed = position.distance_to(closed_position)
		var should_be_open = distance_to_closed > 8.0  # If more than 8px from closed, should be open
		if should_be_open and is_closed:
			LogManager.log_error("Door: ERROR - Door is at open position but is_closed is true! Fixing state...", LogManager.CATEGORY_DOOR)
			is_closed = false
			set_collision_layer_value(7, false)
			LogManager.log("Door: Fixed state - door is now OPEN (is_closed: " + str(is_closed) + ", collision: " + str(get_collision_layer_value(7)) + ")", LogManager.CATEGORY_DOOR)
		elif not should_be_open and not is_closed:
			LogManager.log_error("Door: ERROR - Door is at closed position but is_closed is false! Fixing state...", LogManager.CATEGORY_DOOR)
			is_closed = true
			set_collision_layer_value(7, true)
			LogManager.log("Door: Fixed state - door is now CLOSED (is_closed: " + str(is_closed) + ", collision: " + str(get_collision_layer_value(7)) + ")", LogManager.CATEGORY_DOOR)
	
	# NOTE: Doors are NOT connected via signals to room triggers
	# Instead, room triggers call door._on_room_entered() directly
	# This prevents doors from reacting to ALL room entries, only their own blocking room

func _create_key_indicator():
	# Create visual indicator for key above door
	if key_indicator:
		return  # Already created
	
	key_indicator = Sprite2D.new()
	# Load key texture from loot system
	var key_texture = load("res://assets/gfx/pickups/items_n_shit.png")
	if key_texture:
		key_indicator.texture = key_texture
		key_indicator.hframes = 20
		key_indicator.vframes = 14
		key_indicator.frame = (13 * 20) + 10  # Key frame from loot system
		key_indicator.position = Vector2(0, -24)  # Above door
		key_indicator.visible = false  # Hidden until key is used
		add_child(key_indicator)

func _on_room_entered(body):
	# Player entered the room - close this door if puzzle not solved
	# This door is IN the room that was just entered (room1 == entered room OR blocking_room == entered room)
	if not body.is_in_group("player"):
		return
	
	# Verify this door is in the room we just entered
	if not room_trigger_area:
		return  # No trigger set, don't do anything
	
	var trigger_room = room_trigger_area.room if room_trigger_area.room else {}
	var door_room1 = room1 if room1 else {}
	var door_blocking_room = blocking_room if blocking_room else {}
	
	# Check if door is IN the trigger room (door starts FROM trigger room OR blocking_room == trigger room)
	var door_in_trigger_room = false
	if trigger_room and not trigger_room.is_empty():
		# Check room1 first (door starts FROM this room)
		if door_room1 and not door_room1.is_empty():
			door_in_trigger_room = (door_room1.x == trigger_room.x and door_room1.y == trigger_room.y and \
									door_room1.w == trigger_room.w and door_room1.h == trigger_room.h)
		
		# Also check blocking_room (should match the puzzle room)
		if not door_in_trigger_room and door_blocking_room and not door_blocking_room.is_empty():
			door_in_trigger_room = (door_blocking_room.x == trigger_room.x and door_blocking_room.y == trigger_room.y and \
									door_blocking_room.w == trigger_room.w and door_blocking_room.h == trigger_room.h)
	
	if not door_in_trigger_room:
		# This door is NOT in the trigger room - ignore
		return
	
	# This door is IN the room that was just entered - close it if puzzle not solved
	if type == "StoneDoor" or type == "GateDoor":
		# Close door if puzzle not solved and door is currently open
		if not puzzle_solved:
			# Check both is_closed flag AND actual position to determine door state
			var distance_to_closed = position.distance_to(closed_position) if closed_position != Vector2.ZERO else 999.0
			var is_actually_open = distance_to_closed > 5.0  # If door is more than 5 pixels away from closed_position, it's open
			
			LogManager.log("Door: _on_room_entered() - type: " + str(type) + ", is_closed: " + str(is_closed) + ", is_actually_open: " + str(is_actually_open) + ", position: " + str(position) + ", closed: " + str(closed_position) + ", distance: " + str(distance_to_closed), LogManager.CATEGORY_DOOR)
			
			# CRITICAL: Only close if door is actually open (both flag and position must indicate open)
			# If door is already closed, don't do anything
			if is_actually_open and not is_closing and not is_opening:
				# Door is actually open (position is away from closed position) - close it
				LogManager.log("Door: Closing door on room entry - was at position " + str(position) + " (closed: " + str(closed_position) + ", is_closed: " + str(is_closed) + ", distance: " + str(distance_to_closed) + ")", LogManager.CATEGORY_DOOR)
				
				# Ensure door is at open position before closing
				var expected_open_pos = closed_position + open_offset
				var dist_to_open = position.distance_to(expected_open_pos)
				if dist_to_open > 5.0:
					# Door is not at expected open position - reset to open position first
					LogManager.log("Door: WARNING - Door is not at expected open position! Resetting to open: " + str(expected_open_pos) + " (was at: " + str(position) + ")", LogManager.CATEGORY_DOOR)
					position = expected_open_pos
					global_position = expected_open_pos
					is_closed = false
					set_collision_layer_value(7, false)
				
				_close()
				# Don't check puzzle state immediately - wait for door to finish closing
				# Puzzle state will be checked when closing animation completes (in _process)
				return  # Exit early, don't check puzzle state yet
			elif is_actually_open:
				# Door is open but animation already in progress - don't interfere
				LogManager.log("Door: Door is open but animation in progress, not closing", LogManager.CATEGORY_DOOR)
				return
			elif not is_actually_open:
				# Door is already at closed position - but for StoneDoor/GateDoor, this shouldn't happen on room entry
				# They should start OPEN and then CLOSE when entering room
				# If door is at closed position, it might have been closed already - don't do anything
				LogManager.log("Door: WARNING - Door is already at closed position when entering room! This shouldn't happen for StoneDoor/GateDoor that start open.", LogManager.CATEGORY_DOOR)
				if closed_position != Vector2.ZERO:
					# Ensure exact position and state match
					position = closed_position
					global_position = closed_position
					is_closed = true
					set_collision_layer_value(7, true)  # Collision ENABLED when closed
					LogManager.log("Door: Door was already closed - ensuring state is correct, position: " + str(position) + ", closed: " + str(closed_position), LogManager.CATEGORY_DOOR)
					# Now that door is confirmed closed, check if puzzle is already solved
					# CRITICAL: Only check puzzle state if door is closed - don't check if puzzle is already solved
					if not puzzle_solved:
						_check_puzzle_state()
			# If door is already closing (animation in progress), don't check puzzle state yet
			# Puzzle state will be checked when closing animation completes (in _process)

func _on_room_exited(body):
	# Player left the room
	if not body.is_in_group("player"):
		return
	# Doors stay in their current state

func _check_puzzle_state():
	# Only check puzzle state on server/authority in multiplayer
	if multiplayer.has_multiplayer_peer() and not multiplayer.is_server():
		return  # Clients wait for server to check and sync via RPC
	
	# CRITICAL: Don't check puzzle state while door is animating (closing or opening)
	# This prevents race conditions where switch triggers before door finishes closing
	if is_closing or is_opening:
		LogManager.log("Door: Skipping puzzle check - door is animating (is_closing: " + str(is_closing) + ", is_opening: " + str(is_opening) + ")", LogManager.CATEGORY_DOOR)
		return
	
	# Check door's actual state (position-based check is more reliable than flags)
	var distance_to_closed = position.distance_to(closed_position) if closed_position != Vector2.ZERO else 999.0
	var is_actually_closed = distance_to_closed < 5.0  # Within 5 pixels of closed position
	var is_actually_open = distance_to_closed > 5.0  # More than 5 pixels away from closed position
	var collision_enabled = get_collision_layer_value(7)  # Check if collision layer 7 is enabled
	
	# CRITICAL: If puzzle_solved is true but door is not actually open (not in open position or collision still enabled),
	# allow switch to trigger again to open the door
	# This handles race conditions where switch triggers while door is still closing
	if puzzle_solved and (not is_actually_open or collision_enabled):
		# Door should be open but isn't (position or collision) - reset puzzle_solved to allow switch to trigger again
		LogManager.log("Door: puzzle_solved is true but door is not actually open (position: " + str(is_actually_open) + ", collision: " + str(collision_enabled) + ") - resetting to allow switch to trigger again", LogManager.CATEGORY_DOOR)
		puzzle_solved = false
		switches_activated = false
	
	# Check if all enemies are defeated (enemies in blocking room)
	if requires_enemies and _are_all_enemies_defeated():
		var room_x_str = str(blocking_room.get("x", "?")) if blocking_room and not blocking_room.is_empty() else "?"
		var room_y_str = str(blocking_room.get("y", "?")) if blocking_room and not blocking_room.is_empty() else "?"
		LogManager.log("Door: All enemies defeated! Opening door " + str(name) + " (type: " + str(type) + ", room: " + room_x_str + "," + room_y_str + ")", LogManager.CATEGORY_DOOR)
		enemies_defeated = true
		puzzle_solved = true
		if is_actually_closed:
			_open()
		return
	
	# Check if all required switches are activated (switches in switch_room, before the door)
	var all_switches_active = _are_all_switches_activated()
	
	# Check if any connected switches are pillar switches (for special handling)
	var has_pillar_switch = false
	for switch in connected_switches:
		if is_instance_valid(switch) and "switch_type" in switch and switch.switch_type == "pillar":
			has_pillar_switch = true
			break
	
	if all_switches_active:
		# All switches are active - solve puzzle and open door if closed
		switches_activated = true
		puzzle_solved = true
		# Only open if door is actually closed (not just the flag, but actual position)
		# This prevents race condition where switch triggers while door is still closing
		if is_actually_closed:
			_open()
		return
	else:
		# Not all switches are active
		if puzzle_solved and has_pillar_switch:
			# Pillar switch became inactive and door was open - close it and reset puzzle
			LogManager.log("Door: Pillar switch deactivated - closing door " + str(name), LogManager.CATEGORY_DOOR)
			switches_activated = false
			puzzle_solved = false
			if not is_actually_closed:
				_close()
			return
		elif puzzle_solved and not has_pillar_switch:
			# Walk switch puzzle - once solved, stays solved (door stays open)
			# Don't reset puzzle_solved for walk switches
			return
		else:
			# Puzzle not solved yet - just reset flags
			switches_activated = false
			puzzle_solved = false

func _are_all_enemies_defeated() -> bool:
	# Check if all enemies spawned from spawners in the puzzle room are defeated
	# CRITICAL: Only check enemies that were SPAWNED from spawners (not pre-spawned enemies)
	# Use room1 (the room this door is IN) or blocking_room for checking enemies
	var target_room = room1 if room1 and not room1.is_empty() else blocking_room
	if target_room.is_empty():
		return false
	
	# Find all enemies in the room that were spawned from spawners
	var game_world = get_tree().get_first_node_in_group("game_world")
	var entities_node = null
	if game_world:
		entities_node = game_world.get_node_or_null("Entities")
	if not entities_node:
		# Fallback without throwing if GameWorld isn't ready yet
		entities_node = get_node_or_null("/root/GameWorld/Entities")
	
	if not entities_node:
		return false
	
	var room_spawned_enemies = []
	for child in entities_node.get_children():
		if child.is_in_group("enemy"):
			# CRITICAL: Only check enemies that were spawned from spawners (not pre-spawned)
			if not child.has_meta("spawned_from_spawner") or not child.get_meta("spawned_from_spawner"):
				continue  # Skip pre-spawned enemies
			
			# Check if enemy is in this room (use position-based check, more reliable)
			var enemy_in_room = false
			# Use tile_size and room bounds from parent scope (declared below)
			var enemy_tile_x = int(child.global_position.x / 16)
			var enemy_tile_y = int(child.global_position.y / 16)
			var enemy_room_min_x = target_room.x + 2
			var enemy_room_max_x = target_room.x + target_room.w - 2
			var enemy_room_min_y = target_room.y + 2
			var enemy_room_max_y = target_room.y + target_room.h - 2
			
			if enemy_tile_x >= enemy_room_min_x and enemy_tile_x < enemy_room_max_x and \
			   enemy_tile_y >= enemy_room_min_y and enemy_tile_y < enemy_room_max_y:
				enemy_in_room = true
				# Also check spawner metadata - if enemy has spawner_name matching this room's spawners
				if child.has_meta("spawner_name"):
					var spawner_name = child.get_meta("spawner_name")
					# Spawner names are like "EnemySpawner_<room_x>_<room_y>"
					if str(target_room.x) in spawner_name and str(target_room.y) in spawner_name:
						enemy_in_room = true  # Confirmed by spawner name
			
			if enemy_in_room:
				room_spawned_enemies.append(child)
				var spawner_name = str(child.get_meta("spawner_name")) if child.has_meta("spawner_name") else "unknown"
				var is_dead_str = str(child.is_dead) if "is_dead" in child else "unknown"
				LogManager.log("Door: Found spawned enemy in room: " + str(child.name) + " (spawner: " + spawner_name + ", is_dead: " + is_dead_str + ")", LogManager.CATEGORY_DOOR)
	
	# Check if all spawned enemies are dead
	var target_room_x_str = str(target_room.get("x", "?")) if target_room and not target_room.is_empty() else "?"
	var target_room_y_str = str(target_room.get("y", "?")) if target_room and not target_room.is_empty() else "?"
	LogManager.log("Door: _are_all_enemies_defeated() - Found " + str(room_spawned_enemies.size()) + " spawned enemies in room (" + target_room_x_str + "," + target_room_y_str + ")", LogManager.CATEGORY_DOOR)
	
	# First, check if any enemies in room_spawned_enemies are still alive
	# If any are alive, puzzle is not solved
	for enemy in room_spawned_enemies:
		if is_instance_valid(enemy):
			var enemy_is_dead = false
			if "is_dead" in enemy:
				enemy_is_dead = enemy.is_dead
			else:
				enemy_is_dead = enemy.is_queued_for_deletion() or not enemy.is_inside_tree()
			
			if not enemy_is_dead:
				LogManager.log("Door: Enemy " + str(enemy.name) + " is still alive - puzzle not solved yet", LogManager.CATEGORY_DOOR)
				return false  # Enemy is still alive, puzzle not solved
	
	# If we have enemies and all are dead, puzzle is solved
	if room_spawned_enemies.size() > 0:
		LogManager.log("Door: All " + str(room_spawned_enemies.size()) + " spawned enemies are dead! Puzzle solved!", LogManager.CATEGORY_DOOR)
		return true  # All enemies found are dead
	
	# No spawned enemies found - check if spawners have actually spawned enemies before
	# CRITICAL: Only consider puzzle solved if spawners have spawned enemies and they're all dead
	# Don't solve if spawners haven't spawned yet (e.g., spawn_on_ready=false and player hasn't entered room)
	
	# IMPORTANT: Before checking spawners, verify there are NO ALIVE enemies in the room
	# This catches cases where enemies weren't added to room_spawned_enemies due to position check issues
	var entities_child = entities_node.get_node_or_null("Entities") if entities_node else null
	if not entities_child and entities_node:
		var fallback_game_world = get_tree().get_first_node_in_group("game_world")
		if fallback_game_world:
			entities_child = fallback_game_world.get_node_or_null("Entities")
	
	var tile_size = 16
	var room_min_x = target_room.x + 2
	var room_max_x = target_room.x + target_room.w - 2
	var room_min_y = target_room.y + 2
	var room_max_y = target_room.y + target_room.h - 2
	
	if entities_child:
		for child in entities_child.get_children():
			if child.is_in_group("enemy"):
				# Only check enemies that were spawned from spawners
				if not child.has_meta("spawned_from_spawner") or not child.get_meta("spawned_from_spawner"):
					continue
				
				# Check if enemy is in this room by position
				var enemy_tile_x = int(child.global_position.x / tile_size)
				var enemy_tile_y = int(child.global_position.y / tile_size)
				var enemy_in_room = (enemy_tile_x >= room_min_x and enemy_tile_x < room_max_x and \
									enemy_tile_y >= room_min_y and enemy_tile_y < room_max_y)
				
				if not enemy_in_room:
					continue  # Skip enemies not in this room
				
				# Check if enemy is alive
				var enemy_is_alive = false
				if "is_dead" in child:
					enemy_is_alive = not child.is_dead
				else:
					enemy_is_alive = not child.is_queued_for_deletion() and child.is_inside_tree()
				
				if enemy_is_alive:
					# Found an ALIVE enemy in this room - puzzle not solved!
					LogManager.log("Door: Found ALIVE enemy " + str(child.name) + " in room - puzzle not solved yet (enemy still alive)", LogManager.CATEGORY_DOOR)
					return false
	
	# No alive enemies found in room - now check if spawners have spawned
	if room_spawned_enemies.size() == 0:
		# No spawned enemies found - check if spawners have actually spawned enemies before
		# CRITICAL: Only consider puzzle solved if spawners have spawned enemies and they're all dead
		# Don't solve if spawners haven't spawned yet (e.g., spawn_on_ready=false and player hasn't entered room)
		
		var spawners_in_room = []
		var spawners_that_have_spawned = []
		
		# First, check ALL spawners in the room (including destroyed ones by checking for enemies with their names)
		for spawner in get_tree().get_nodes_in_group("enemy_spawner"):
			if is_instance_valid(spawner):
				var spawner_tile_x = int(spawner.global_position.x / 16)
				var spawner_tile_y = int(spawner.global_position.y / 16)
				if spawner_tile_x >= target_room.x + 2 and spawner_tile_x < target_room.x + target_room.w - 2 and \
				   spawner_tile_y >= target_room.y + 2 and spawner_tile_y < target_room.y + target_room.h - 2:
					spawners_in_room.append(spawner)
					
					# Check if this spawner has spawned by multiple methods:
					# 1. Check if spawner has has_ever_spawned flag (most reliable)
					# 2. Check if any enemies in scene were spawned by this spawner
					# 3. Check if spawner has spawned_enemies list with valid enemies
					var has_spawned = false
					
					# First, check if spawner has has_ever_spawned flag
					if "has_ever_spawned" in spawner and spawner.has_ever_spawned:
						has_spawned = true
					
					# Also check if any enemies in scene were spawned by this spawner (ONLY if they're dead/removed)
					# If we find ALIVE enemies, don't mark spawner as spawned - wait until they're dead
					if not has_spawned:
						var entities_child_for_spawner = entities_node.get_node_or_null("Entities") if entities_node else null
						if not entities_child_for_spawner and entities_node:
							var fallback_game_world = get_tree().get_first_node_in_group("game_world")
							if fallback_game_world:
								entities_child_for_spawner = fallback_game_world.get_node_or_null("Entities")
						
						if entities_child_for_spawner:
							for child in entities_child_for_spawner.get_children():
								if child.is_in_group("enemy"):
									if child.has_meta("spawner_name") and child.get_meta("spawner_name") == spawner.name:
										# Found an enemy spawned by this spawner
										# Check if it's alive - if alive, don't mark spawner as spawned yet
										var enemy_is_alive = false
										if "is_dead" in child:
											enemy_is_alive = not child.is_dead
										else:
											enemy_is_alive = not child.is_queued_for_deletion() and child.is_inside_tree()
										
										if not enemy_is_alive:
											# Enemy is dead - spawner has spawned
											has_spawned = true
											break
										# If enemy is alive, don't mark spawner as spawned - wait until it's dead
					
					# Also check if spawner currently has enemies in its spawned_enemies list
					# Only count if all enemies in the list are dead (puzzle can only be solved when all are dead)
					if not has_spawned and "spawned_enemies" in spawner:
						var spawned_enemies_list = spawner.spawned_enemies
						if spawned_enemies_list and spawned_enemies_list.size() > 0:
							# Check if all enemies in list are dead
							var all_enemies_dead = true
							for enemy in spawned_enemies_list:
								if is_instance_valid(enemy):
									var enemy_is_dead = false
									if "is_dead" in enemy:
										enemy_is_dead = enemy.is_dead
									else:
										enemy_is_dead = enemy.is_queued_for_deletion() or not enemy.is_inside_tree()
									
									if not enemy_is_dead:
										all_enemies_dead = false
										break
							
							# Only mark spawner as spawned if all enemies are dead
							if all_enemies_dead:
								has_spawned = true
					
					if has_spawned:
						spawners_that_have_spawned.append(spawner)
		
		# Also check for spawners that may have been destroyed but had enemies spawned
		# Look for any dead enemies with spawner name matching this room AND position in this room
		var spawner_name_pattern = "EnemySpawner_" + str(target_room.x) + "_" + str(target_room.y)
		var found_dead_enemies_with_matching_spawner = []
		if entities_child:
			for child in entities_child.get_children():
				if child.is_in_group("enemy"):
					# Only check enemies that were spawned from spawners
					if not child.has_meta("spawned_from_spawner") or not child.get_meta("spawned_from_spawner"):
						continue
					
					# Check if enemy is in this room by position
					var enemy_tile_x = int(child.global_position.x / tile_size)
					var enemy_tile_y = int(child.global_position.y / tile_size)
					var enemy_in_room = (enemy_tile_x >= room_min_x and enemy_tile_x < room_max_x and \
										enemy_tile_y >= room_min_y and enemy_tile_y < room_max_y)
					
					if not enemy_in_room:
						continue  # Skip enemies not in this room
					
					# Check if enemy is dead
					var enemy_is_dead = false
					if "is_dead" in child:
						enemy_is_dead = child.is_dead
					else:
						enemy_is_dead = child.is_queued_for_deletion() or not child.is_inside_tree()
					
					# Only check dead/removed enemies as evidence that spawners spawned
					if enemy_is_dead and child.has_meta("spawner_name"):
						var enemy_spawner_name = child.get_meta("spawner_name")
						if spawner_name_pattern in enemy_spawner_name or enemy_spawner_name == spawner_name_pattern:
							found_dead_enemies_with_matching_spawner.append(child)
		
		# Track unique spawner names that have spawned (only based on dead enemies)
		var unique_spawner_names_that_spawned = {}
		for enemy in found_dead_enemies_with_matching_spawner:
			if enemy.has_meta("spawner_name"):
				var spawner_name = enemy.get_meta("spawner_name")
				unique_spawner_names_that_spawned[spawner_name] = true
		
		# Only mark spawners as spawned if we found DEAD enemies (ensures puzzle only solves when all are dead)
		if unique_spawner_names_that_spawned.size() > 0:
			# Found dead enemies with matching spawner names - spawners definitely spawned and enemies are dead
			if spawners_in_room.size() == 0:
				for spawner_name in unique_spawner_names_that_spawned.keys():
					spawners_in_room.append(null)  # Placeholder for destroyed spawner
					spawners_that_have_spawned.append(null)  # Count as spawned
					LogManager.log("Door: Spawner " + str(spawner_name) + " was destroyed but spawned enemies that are now all dead - counting as spawned", LogManager.CATEGORY_DOOR)
			else:
				# Spawners exist - check if any weren't counted as spawned yet
				for spawner_name in unique_spawner_names_that_spawned.keys():
					var spawner_already_counted = false
					for spawned_spawner in spawners_that_have_spawned:
						if is_instance_valid(spawned_spawner) and spawned_spawner.name == spawner_name:
							spawner_already_counted = true
							break
					
					if not spawner_already_counted:
						for i in range(spawners_in_room.size()):
							var spawner = spawners_in_room[i]
							if is_instance_valid(spawner) and spawner.name == spawner_name:
								spawners_that_have_spawned.append(spawner)
								LogManager.log("Door: Found dead enemy from spawner " + str(spawner_name) + " - marking as spawned", LogManager.CATEGORY_DOOR)
								break
		
		
		# Only solve if:
		# 1. There are spawners in the room (or were spawners that spawned)
		# 2. All spawners have spawned enemies
		# 3. All those enemies are now dead (since no enemies found in room)
		
		# Count valid spawners (including null placeholders for destroyed spawners)
		var valid_spawners_count = spawners_in_room.size()
		var valid_spawned_count = spawners_that_have_spawned.size()
		
		# If we have spawners (including destroyed ones) and they've all spawned, puzzle is solved
		if valid_spawners_count > 0 and valid_spawned_count >= valid_spawners_count:
			# All spawners in room have spawned at least once, and no enemies found in room
			# This means all spawned enemies are dead - puzzle solved!
			LogManager.log("Door: No spawned enemies found, but all " + str(valid_spawners_count) + " spawners in room have spawned enemies that are all dead - puzzle solved!", LogManager.CATEGORY_DOOR)
			return true
		
		# Also check: if no spawners found (they were destroyed), but this is a puzzle room (has blocking doors),
		# and we previously found enemies with matching spawner names that are now gone,
		# consider the puzzle solved
		if valid_spawners_count == 0 and valid_spawned_count > 0:
			# Spawners were destroyed, but we found evidence they spawned
			# Since no enemies found, they must all be dead - puzzle solved!
			LogManager.log("Door: No spawners or enemies found, but found evidence of spawned enemies that are now all dead - puzzle solved!", LogManager.CATEGORY_DOOR)
			return true
		
		if valid_spawners_count > 0:
			LogManager.log("Door: Spawners in room (" + str(valid_spawners_count) + ") but only " + str(valid_spawned_count) + " have spawned - puzzle not solved yet", LogManager.CATEGORY_DOOR)
		else:
			LogManager.log("Door: No spawned enemies found in room - puzzle not solved yet (enemies may not have spawned or already removed)", LogManager.CATEGORY_DOOR)
		return false
	
	for enemy in room_spawned_enemies:
		if is_instance_valid(enemy):
			var enemy_is_dead = false
			if "is_dead" in enemy:
				enemy_is_dead = enemy.is_dead
			else:
				# Check if enemy is queued for deletion or removed from scene
				enemy_is_dead = enemy.is_queued_for_deletion() or not enemy.is_inside_tree()
			
			if not enemy_is_dead:
				LogManager.log("Door: Enemy " + str(enemy.name) + " is still alive (is_dead: " + str(enemy_is_dead) + ", is_queued: " + str(enemy.is_queued_for_deletion()) + ", in_tree: " + str(enemy.is_inside_tree()) + ")", LogManager.CATEGORY_DOOR)
				return false
		else:
			# Enemy is no longer valid (removed from scene) - consider it dead
			LogManager.log("Door: Enemy is no longer valid (removed from scene) - counting as dead", LogManager.CATEGORY_DOOR)
	
	LogManager.log("Door: All " + str(room_spawned_enemies.size()) + " spawned enemies are dead! Puzzle solved!", LogManager.CATEGORY_DOOR)
	return true  # All enemies are dead

func _spawn_smoke_puffs_on_close():
	# Spawn 1-3 smoke puffs when StoneDoor finishes closing
	if not smoke_puff_scene:
		return
	
	var puff_count = randi_range(1, 3)  # Random between 1-3 puffs
	
	for i in range(puff_count):
		var puff = smoke_puff_scene.instantiate()
		if puff:
			# Spawn at door position with small random offset
			var offset_x = randf_range(-8, 8)
			var offset_y = randf_range(-8, 8)
			puff.global_position = global_position + Vector2(offset_x, offset_y)
			puff.z_index = 10  # High z-index to ensure visibility
			
			# Add to Entities node for proper layering
			var entities_node = get_tree().get_first_node_in_group("game_world")
			if entities_node:
				entities_node = entities_node.get_node_or_null("Entities")
				if entities_node:
					entities_node.add_child(puff)
				else:
					# Fallback: add to scene root
					get_tree().current_scene.add_child(puff)
			else:
				# Fallback: add to scene root
				get_tree().current_scene.add_child(puff)

func _spawn_smoke_puffs_on_open():
	# Spawn 1-2 smoke puffs when StoneDoor starts opening
	if not smoke_puff_scene:
		return
	
	var puff_count = randi_range(1, 2)  # Random between 1-2 puffs
	
	for i in range(puff_count):
		var puff = smoke_puff_scene.instantiate()
		if puff:
			# Spawn at door position with small random offset
			var offset_x = randf_range(-8, 8)
			var offset_y = randf_range(-8, 8)
			puff.global_position = global_position + Vector2(offset_x, offset_y)
			puff.z_index = 10  # High z-index to ensure visibility
			
			# Add to Entities node for proper layering
			var entities_node = get_tree().get_first_node_in_group("game_world")
			if entities_node:
				entities_node = entities_node.get_node_or_null("Entities")
				if entities_node:
					entities_node.add_child(puff)
				else:
					# Fallback: add to scene root
					get_tree().current_scene.add_child(puff)
			else:
				# Fallback: add to scene root
				get_tree().current_scene.add_child(puff)

func _are_all_switches_activated() -> bool:
	# Check if all required switches are activated
	# CRITICAL: ONLY check connected_switches - switches are explicitly connected when spawned
	# Do NOT use position-based fallback checks - they cause cross-room door triggering!
	if connected_switches.size() > 0:
		# Check all connected switches (these are the switches in THIS door's puzzle room)
		var switch_room_x = str(blocking_room.get("x", "?")) if blocking_room and not blocking_room.is_empty() else "?"
		var switch_room_y = str(blocking_room.get("y", "?")) if blocking_room and not blocking_room.is_empty() else "?"
		LogManager.log("Door: _are_all_switches_activated() - Checking " + str(connected_switches.size()) + " connected switches for door " + str(name) + " (room: " + switch_room_x + "," + switch_room_y + ")", LogManager.CATEGORY_DOOR)
		for switch in connected_switches:
			if not is_instance_valid(switch):
				continue
			# is_activated is a variable, not a method
			if not switch.is_activated:
				LogManager.log("Door: Switch " + str(switch.name) + " is NOT activated", LogManager.CATEGORY_DOOR)
				return false
		LogManager.log("Door: All connected switches are activated!", LogManager.CATEGORY_DOOR)
		return true  # All connected switches are activated
	
	# CRITICAL: If no switches are connected, the puzzle is NOT solved!
	# Switches should ALWAYS be connected when spawned - if they're not, it's an error
	LogManager.log("Door: WARNING - Door " + str(name) + " has no connected switches! Puzzle cannot be solved!", LogManager.CATEGORY_DOOR)
	return false  # No connected switches means puzzle is NOT solved

func _on_key_interaction_area_body_entered(body):
	# Player entered key interaction area
	if not body.is_in_group("player"):
		return
	
	if type == "KeyDoor" and is_closed and not key_used:
		# Check if player has a key
		if body.has_method("has_key") and body.has_method("use_key"):
			if body.has_key():
				# Use key and open door
				body.use_key()
				key_used = true
				_show_key_indicator()
				_open()
				LogManager.log("KeyDoor opened with key!", LogManager.CATEGORY_DOOR)

func _show_key_indicator():
	# Show key indicator above door
	if key_indicator:
		key_indicator.visible = true
		# Make sure it's on top (higher z-index or add to front)
		key_indicator.z_index = 10
		move_child(key_indicator, get_child_count() - 1)  # Move to front
	else:
		# Create key indicator if it doesn't exist yet
		_create_key_indicator()
		if key_indicator:
			key_indicator.visible = true

func teleportPlayer(body: Node2D):
	# Only teleport on server in multiplayer (server is authority for all players)
	if multiplayer.has_multiplayer_peer() and not multiplayer.is_server():
		# Client should wait for server to sync position
		return
	
	var keydoor_open_offset = Vector2.ZERO
	match direction:
		"Up":
			keydoor_open_offset = Vector2(0, 16)  # Open is 16px UP from closed
		"Down":
			keydoor_open_offset = Vector2(0, -16)  # Open is 16px DOWN from closed (row 0 to row 1)
		"Left":
			keydoor_open_offset = Vector2(16, 0)  # Open is 16px LEFT from closed
		"Right":
			keydoor_open_offset = Vector2(-16, 0)  # Open is 16px RIGHT from closed
	
	var new_position = self.global_position + keydoor_open_offset
	
	if body.is_in_group("player"):
		# Player teleportation - set position on server and sync to all clients
		if multiplayer.has_multiplayer_peer() and multiplayer.is_server():
			# Server: set position directly and sync to all clients
			body.global_position = new_position
			# Also reset velocity to prevent player from moving back
			if "velocity" in body:
				body.velocity = Vector2.ZERO
			# Sync position to all clients (including the teleported player's client)
			if body.has_method("_sync_teleport_position") and body.can_send_rpcs and body.is_inside_tree():
				body._sync_teleport_position.rpc(new_position)
		else:
			# Single-player: just set position
			body.global_position = new_position
			if "velocity" in body:
				body.velocity = Vector2.ZERO
	else:
		# Non-player teleportation (shouldn't happen, but handle it)
		body.global_position = new_position
	pass

@rpc("authority", "reliable")
func _sync_door_open():
	# Client receives door open RPC - open the door locally
	if multiplayer.has_multiplayer_peer() and not multiplayer.is_server():
		# Only open if door is closed (avoid reopening already open doors)
		var distance_to_closed = position.distance_to(closed_position) if closed_position != Vector2.ZERO else 999.0
		var is_actually_open = distance_to_closed > 5.0
		
		if not is_actually_open and not is_opening:
			# Door is closed - open it
			if closed_position != Vector2.ZERO:
				position = closed_position
				global_position = closed_position
				is_closed = true
				set_collision_layer_value(7, true)
			
			# CRITICAL: For KeyDoors, set key_used to true so it doesn't get reset to closed
			if type == "KeyDoor":
				key_used = true
			
			animation_start_position = position
			is_opening = true
			is_closing = false
			move_timer = 0.0
			
			# Play sound effect on client
			if type == "KeyDoor":
				$SfxOpenKeyDoor.play()
			elif type == "GateDoor":
				$SfxOpenGateDoor.play()
			else:
				$SfxOpenStoneDoor.play()
			
			var key_used_str = " (key_used=" + str(key_used) + ")" if type == "KeyDoor" else ""
			LogManager.log("Door: Client received door open RPC for " + str(name) + " - starting open animation" + key_used_str, LogManager.CATEGORY_DOOR)

@rpc("authority", "reliable")
func _sync_puzzle_solved(is_solved: bool):
	# Client receives puzzle solved state sync
	if multiplayer.has_multiplayer_peer() and not multiplayer.is_server():
		puzzle_solved = is_solved
		if is_solved:
			enemies_defeated = true
			switches_activated = true
		LogManager.log("Door: Client received puzzle_solved sync for " + str(name) + " - puzzle_solved: " + str(is_solved), LogManager.CATEGORY_DOOR)

@rpc("authority", "reliable")
func _sync_door_close():
	# Client receives door close RPC - close the door locally
	if multiplayer.has_multiplayer_peer() and not multiplayer.is_server():
		# Only close if door is open (avoid reclosing already closed doors)
		var distance_to_closed = position.distance_to(closed_position) if closed_position != Vector2.ZERO else 999.0
		var is_actually_at_closed = distance_to_closed < 5.0
		
		if not is_actually_at_closed and not is_closing:
			# Door is open - close it
			var expected_open_pos = closed_position + open_offset
			var distance_to_open = position.distance_to(expected_open_pos)
			
			if distance_to_open > 10.0:
				animation_start_position = expected_open_pos
				position = expected_open_pos
				global_position = expected_open_pos
			else:
				animation_start_position = position
			
			is_opening = false
			is_closing = true
			move_timer = 0.0
			
			LogManager.log("Door: Client received door close RPC for " + str(name) + " - starting close animation", LogManager.CATEGORY_DOOR)