extends Node3D
class_name LevelRuntime

var _player: CharacterBody3D


func _ready() -> void:
	# Hide mouse
	Input.mouse_mode = Input.MOUSE_MODE_CAPTURED

	# Maps that don't ship their own environment get the shared stylized one
	# (sky gradient, sun+fill, glow, cel color grade, ambient bed).
	if not has_node("WorldEnvironment"):
		LevelEnvironment.add_to(self)

	
	# Multiplayer Spawning
	var spawner = MultiplayerSpawner.new()
	spawner.name = "PlayerSpawner"
	spawner.spawn_path = "." # Spawn directly as children of the level
	spawner.spawn_function = _spawn_player
	add_child(spawner)
	
	var nm = get_node_or_null("/root/NetworkManager")
	if nm and nm.multiplayer.is_server():
		# Spawn existing players
		for pid in nm.player_stats.keys():
			spawner.spawn(pid)
		
		# Spawn late joiners
		nm.player_connected.connect(func(pid):
			spawner.spawn(pid)
		)
		
		# Despawn on disconnect
		nm.player_disconnected.connect(func(pid):
			var p = get_node_or_null(str(pid))
			if p:
				p.queue_free()
		)


# ── Spawning ──────────────────────────────────────────────────────────────────

func _get_dynamic_spawn_position() -> Vector3:
	var spawn_nodes = get_tree().get_nodes_in_group("spawn_points")
	if spawn_nodes.is_empty():
		return Vector3(0, 10, 0)
	
	var all_players = []
	for p in get_tree().get_nodes_in_group("players"):
		if is_instance_valid(p) and p is Node3D:
			all_players.append(p)
			
	if all_players.is_empty():
		var pos = spawn_nodes.pick_random().global_position
		pos += Vector3(randf_range(-1, 1), 0.5, randf_range(-1, 1))
		return pos
		
	var best_spawn = spawn_nodes[0].global_position
	var max_min_dist = -1.0
	
	for spawn_node in spawn_nodes:
		var pos = spawn_node.global_position
		var min_dist_to_player = 999999.0
		for p in all_players:
			var dist = pos.distance_to(p.global_position)
			if dist < min_dist_to_player:
				min_dist_to_player = dist
				
		if min_dist_to_player > max_min_dist:
			max_min_dist = min_dist_to_player
			best_spawn = pos
			
	# Add slight jitter to prevent exact stacking
	best_spawn += Vector3(randf_range(-1, 1), 0.5, randf_range(-1, 1))
	return best_spawn

func _spawn_player(pid: int) -> CharacterBody3D:
	var player := CharacterBody3D.new()
	player.name = str(pid)
	player.set_multiplayer_authority(pid)
	player.add_to_group("players")
	
	# Dynamic Spawning
	player.position = _get_dynamic_spawn_position()
	
	# Server Synchronizer — host-owned gameplay state (health, kills, death)
	var server_sync = MultiplayerSynchronizer.new()
	server_sync.name = "ServerSynchronizer"
	server_sync.set_multiplayer_authority(1) # Host always controls these
	var server_rep_config = SceneReplicationConfig.new()
	server_rep_config.add_property(":health")
	server_rep_config.add_property(":shield")
	server_rep_config.add_property(":is_dead")
	server_sync.replication_config = server_rep_config
	player.add_child(server_sync)

	# Client Synchronizer — owner-simulated movement, aim, animation state.
	# Movement is client-authoritative for instant response; remote peers
	# interpolate synced_position/velocity (see PlayerMovementController).
	var client_sync = MultiplayerSynchronizer.new()
	client_sync.name = "MultiplayerSynchronizer"
	client_sync.set_multiplayer_authority(pid)
	var client_rep_config = SceneReplicationConfig.new()
	client_rep_config.add_property(":synced_position")
	client_rep_config.add_property(":synced_velocity")
	client_rep_config.add_property(":rotation")
	client_rep_config.add_property("HeadPivot:rotation")
	client_rep_config.add_property(":synced_movement_state")
	client_rep_config.add_property(":synced_movement_speed")
	client_rep_config.add_property(":synced_is_crouching")
	client_rep_config.add_property(":synced_is_ads")
	client_rep_config.add_property(":synced_wall_side")
	client_rep_config.add_property(":synced_is_dancing")
	# Which of the five emotes, so other players see the one that was chosen.
	client_rep_config.add_property(":synced_dance_index")
	client_rep_config.add_property(":synced_grapple_point")
	client_rep_config.add_property(":synced_is_grapple_shooting")
	client_rep_config.add_property(":synced_skin_id")
	client_rep_config.add_property(":synced_weapon_path")
	client_rep_config.add_property(":synced_loadout_p1")
	client_rep_config.add_property(":synced_loadout_p2")
	client_rep_config.add_property(":synced_loadout_sp")
	client_rep_config.add_property(":synced_loadout_melee")
	client_rep_config.add_property(":synced_loadout_ready")
	client_rep_config.add_property(":synced_action")
	client_rep_config.add_property(":synced_action_seq")
	client_rep_config.add_property(":synced_is_targeting")
	client_rep_config.add_property(":synced_homing_target_pos")
	client_sync.replication_config = client_rep_config
	player.add_child(client_sync)

	# Collision shape
	var col_shape := CollisionShape3D.new()
	col_shape.name = "CollisionShape3D"
	var capsule := CapsuleShape3D.new()
	capsule.radius = 0.4
	capsule.height = 1.8
	col_shape.shape = capsule
	player.add_child(col_shape)

	# Apply movement controller script
	var mover_script = preload("res://movement/player_movement_controller.gd")
	if mover_script:
		player.set_script(mover_script)
		
	# Humanoid Model for Player (Shadows only locally, visible to others)
	var humanoid = load("res://characters/humanoid_model.gd").new()
	humanoid.name = "HumanoidModel"
	humanoid.color = Color(0.2, 0.4, 0.8) # Blueish for player
	humanoid.shadows_only = (pid == multiplayer.get_unique_id())
	humanoid.position = Vector3(0, -0.9, 0) # Offset from center to feet
	player.add_child(humanoid)

	# Movement State Machine
	var sm := Node.new()
	sm.name = "MovementStateMachine"
	player.add_child(sm)

	var sm_script = preload("res://movement/movement_state_machine.gd")
	if sm_script:
		sm.set_script(sm_script)

	# Add all movement states
	var state_scripts := {
		"ground": "res://movement/states/state_ground.gd",
		"air": "res://movement/states/state_air.gd",
		"wall_run": "res://movement/states/state_wall_run.gd",
		"wall_cling": "res://movement/states/state_wall_cling.gd",
		"slide": "res://movement/states/state_slide.gd",
		"dash": "res://movement/states/state_dash.gd",
	}
	for state_name in state_scripts:
		var st := Node.new()
		st.name = "state_" + state_name
		sm.add_child(st)
		var st_script = load(state_scripts[state_name])
		if st_script:
			st.set_script(st_script)

	# FPS Camera Rig (HeadPivot → Camera3D)
	var head_pivot := Node3D.new()
	head_pivot.name = "HeadPivot"
	head_pivot.position = Vector3(0, 0.7, 0)  # Eye height
	player.add_child(head_pivot)

	var camera := Camera3D.new()
	camera.name = "Camera3D"
	camera.current = (pid == multiplayer.get_unique_id())
	camera.fov = 90.0
	head_pivot.add_child(camera)
	
	# ── Weapon Setup ────────────────────────────────────────────────────────────
	var wmanager_script = preload("res://weapons/weapon_manager.gd")
	if wmanager_script:
		var wman = wmanager_script.new()
		wman.name = "WeaponManager"
		wman.player = player
		wman.camera = camera
		camera.add_child(wman)

	var rig_script = preload("res://characters/player/fps_camera_rig.gd")
	if rig_script:
		head_pivot.set_script(rig_script)

	# Store original capsule height
	sm.original_capsule_height = capsule.height

	# ── Dependencies ────────────────────────────────────────────────────────
	sm.player = player
	sm.params = player.params
	head_pivot.params = player.params

	# Authority configuration
	var is_local = (pid == multiplayer.get_unique_id())
	if is_local:
		_player = player
		player.set_physics_process(true)
		player.set_process(true)
		sm.set_physics_process(true)
	else:
		player.set_physics_process(false)
		player.set_process(true)
		player.set_process_input(false)
		sm.set_physics_process(false)
		sm.set_process(false)
		sm.set_process_input(false)
		head_pivot.set_process_input(false)
		head_pivot.set_process(false)
		head_pivot.set_physics_process(false)
		var wman = camera.get_node_or_null("WeaponManager")
		if wman:
			wman.set_process_input(false)
			wman.set_process(false)
			wman.set_physics_process(false)
			wman.visible = false
			var cv = wman.get("canvas_layer")
			if cv:
				cv.visible = false

	return player


# ── HUD ───────────────────────────────────────────────────────────────
#
# There is no HUD here any more, and no _process to drive one.
#
# Reticle, vitals, ammo, ability cooldowns, the chain meter and the debug
# readout all belong to ui/player_hud.gd, spawned by the player itself. Every
# one of those describes A PLAYER, so a level that owns them has to reach down
# into that player's state machine and weapon manager every frame to fill them
# in — which is exactly what this did, from three byte-identical copies across
# the three level runtimes. The visible symptom was two ammo panels on screen at
# once, in two different styles, overlapping in the bottom-right corner.
#
# A level owns the level.