extends Node3D
class_name TestLevelBuilder

## Builds a full test environment from code — parkour geometry, lighting, player, HUD.
## Attach to TestLevel root, press F5.

var _player: CharacterBody3D


func _ready() -> void:
	# Hide mouse
	Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
	
	_build_materials()
	_build_geometry()
	
	# 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()
		)


func _build_materials() -> void:
	pass


func _build_geometry() -> void:
	_build_environment()
	_build_floor()
	_build_walls_arena()
	_build_ramps()
	_build_platforms()
	_build_wall_run_corridor()
	_build_speed_corridor()
	_build_target_dummy()
	_build_lighting()


# ── Utility ───────────────────────────────────────────────────────────────────

func _box_static(pos: Vector3, size: Vector3, color: Color, node_name: String = "",
		acoustic: String = "") -> StaticBody3D:
	var body := StaticBody3D.new()
	body.name = node_name if not node_name.is_empty() else "Static_%s" % str(pos)
	body.position = pos
	if acoustic != "":
		body.set_meta("acoustic_material", acoustic)
	add_child(body)
	var shape := CollisionShape3D.new()
	shape.shape = BoxShape3D.new()
	shape.shape.size = size
	body.add_child(shape)
	var mesh := MeshInstance3D.new()
	mesh.mesh = BoxMesh.new()
	mesh.mesh.size = size
	mesh.mesh.surface_set_material(0, LevelMaterials.tinted(color))
	body.add_child(mesh)
	return body


func _ramp_static(pos: Vector3, size: Vector3, rot_deg: Vector3, color: Color, node_name: String = "",
		acoustic: String = "") -> StaticBody3D:
	var body := _box_static(pos, size, color, node_name, acoustic)
	body.rotation_degrees = rot_deg
	return body


# ── Environment ───────────────────────────────────────────────────────────────

func _build_environment() -> void:
	# Shared stylized environment (anime sky, bloom, cel color grade).
	# Also creates the Sun/FillLight pair since none exists yet.
	LevelEnvironment.add_to(self)


# ── Floor ─────────────────────────────────────────────────────────────────────

func _build_floor() -> void:
	# Main arena floor (80x80)
	_box_static(Vector3(0, -0.5, 0), Vector3(80, 1.0, 80), Color(0.22, 0.22, 0.25), "Floor_Main")


# ── Arena Walls ───────────────────────────────────────────────────────────────

func _build_walls_arena() -> void:
	var wall_color := Color(0.35, 0.28, 0.22)
	var wall_height := 10.0
	# North
	_box_static(Vector3(0, wall_height * 0.5, -40), Vector3(80, wall_height, 0.5), wall_color, "Wall_North", "brick")
	# South
	_box_static(Vector3(0, wall_height * 0.5, 40), Vector3(80, wall_height, 0.5), wall_color, "Wall_South", "brick")
	# East
	_box_static(Vector3(40, wall_height * 0.5, 0), Vector3(0.5, wall_height, 80), wall_color, "Wall_East", "brick")
	# West
	_box_static(Vector3(-40, wall_height * 0.5, 0), Vector3(0.5, wall_height, 80), wall_color, "Wall_West", "brick")


# ── Ramps ─────────────────────────────────────────────────────────────────────

func _build_ramps() -> void:
	var ramp_color := Color(0.6, 0.35, 0.15)  # Orange-brown

	# Gentle ramp (15 degrees)
	_ramp_static(Vector3(-25, 1.0, -25), Vector3(8, 0.4, 12), Vector3(15, 0, 0), ramp_color, "Ramp_Gentle")

	# Medium ramp (30 degrees)
	_ramp_static(Vector3(-25, 2.0, -15), Vector3(8, 0.4, 10), Vector3(30, 0, 0), ramp_color, "Ramp_Medium")

	# Steep ramp (45 degrees)
	_ramp_static(Vector3(-25, 3.0, -5), Vector3(8, 0.4, 8), Vector3(45, 0, 0), ramp_color, "Ramp_Steep")

	# Quarter pipe (curved ramp approximation)
	for i in range(6):
		var angle := float(i) * 15.0
		var x_off := sin(deg_to_rad(angle)) * 5.0
		var y_off := (1.0 - cos(deg_to_rad(angle))) * 5.0
		_ramp_static(
			Vector3(-25 + x_off, y_off + 0.2, 8 + float(i) * 0.5),
			Vector3(8, 0.3, 2),
			Vector3(angle, 0, 0),
			Color(0.7, 0.4, 0.2),
			"QuarterPipe_%d" % i
		)


# ── Platforms ─────────────────────────────────────────────────────────────────

func _build_platforms() -> void:
	var plat_color := Color(0.2, 0.45, 0.55)  # Teal

	# Low platforms (jump height test)
	_box_static(Vector3(10, 0.6, -20), Vector3(4, 1.2, 4), plat_color, "Plat_Low_1", "wood")
	_box_static(Vector3(16, 0.6, -20), Vector3(4, 1.2, 4), plat_color, "Plat_Low_2", "wood")
	_box_static(Vector3(22, 0.6, -20), Vector3(4, 1.2, 4), plat_color, "Plat_Low_3", "wood")

	# Medium platforms (double jump required)
	var med_color := Color(0.25, 0.5, 0.4)
	_box_static(Vector3(10, 2.5, -28), Vector3(3, 0.5, 3), med_color, "Plat_Med_1", "wood")
	_box_static(Vector3(16, 3.5, -28), Vector3(3, 0.5, 3), med_color, "Plat_Med_2", "wood")
	_box_static(Vector3(22, 4.5, -28), Vector3(3, 0.5, 3), med_color, "Plat_Med_3", "wood")
	_box_static(Vector3(28, 5.5, -28), Vector3(3, 0.5, 3), med_color, "Plat_Med_4", "wood")

	# High tower
	_box_static(Vector3(28, 4.0, -20), Vector3(5, 8.0, 5), Color(0.3, 0.3, 0.5), "Tower_1")

	# Floating platforms (dash required)
	var dash_color := Color(0.6, 0.2, 0.5)  # Purple
	_box_static(Vector3(10, 5.0, -35), Vector3(2.5, 0.3, 2.5), dash_color, "Plat_Dash_1", "metal")
	_box_static(Vector3(18, 5.0, -35), Vector3(2.5, 0.3, 2.5), dash_color, "Plat_Dash_2", "metal")
	_box_static(Vector3(26, 5.0, -35), Vector3(2.5, 0.3, 2.5), dash_color, "Plat_Dash_3", "metal")


# ── Wall Run Corridor ────────────────────────────────────────────────────────

func _build_wall_run_corridor() -> void:
	var wall_color := Color(0.45, 0.25, 0.55)  # Purple walls

	# Two parallel walls — spaced for wall running
	# Left wall
	_box_static(Vector3(-5, 5, 15), Vector3(0.5, 10, 25), wall_color, "WallRun_Left", "metal")
	# Right wall
	_box_static(Vector3(5, 5, 15), Vector3(0.5, 10, 25), wall_color, "WallRun_Right", "metal")

	# Obstacles in corridor to jump over
	_box_static(Vector3(0, 0.75, 10), Vector3(10, 1.5, 1), Color(0.6, 0.3, 0.3), "Obstacle_1", "wood")
	_box_static(Vector3(0, 0.75, 20), Vector3(10, 1.5, 1), Color(0.6, 0.3, 0.3), "Obstacle_2", "wood")

	# Gap in floor (forces wall run)
	# Just raise the floor slightly on each side with a gap
	_box_static(Vector3(-3, -0.75, 25), Vector3(4, 0.5, 4), Color(0.22, 0.22, 0.25), "WallRun_Floor_L")
	_box_static(Vector3(3, -0.75, 25), Vector3(4, 0.5, 4), Color(0.22, 0.22, 0.25), "WallRun_Floor_R")

	# Label pillar at entrance
	_box_static(Vector3(0, 2, 2), Vector3(1, 4, 1), Color(0.55, 0.35, 0.65), "WallRun_Marker")


# ── Speed Corridor ────────────────────────────────────────────────────────────

func _build_speed_corridor() -> void:
	# Long straight for sprint→slide→bhop chains
	var corridor_color := Color(0.2, 0.35, 0.2)  # Dark green

	# Side rails
	_box_static(Vector3(30, 1.5, 0), Vector3(0.3, 3, 60), corridor_color, "SpeedRail_Left", "metal")
	_box_static(Vector3(38, 1.5, 0), Vector3(0.3, 3, 60), corridor_color, "SpeedRail_Right", "metal")

	# Speed bumps (small obstacles to hop over)
	for i in range(-25, 26, 10):
		_box_static(Vector3(34, 0.15, float(i)), Vector3(8, 0.3, 0.5), Color(0.8, 0.8, 0.2), "SpeedBump_%d" % i)


# ── Dummies ───────────────────────────────────────────────────────────────────

func _build_target_dummy() -> void:
	var dummy = load("res://entities/target_dummy.gd").new()
	dummy.name = "TargetDummy"
	# Place it somewhat centrally in the main arena, but out of the immediate spawn area
	dummy.position = Vector3(0, 0, -10)
	add_child(dummy)

	var killable = load("res://entities/killable_dummy.gd").new()
	killable.name = "KillableDummy"
	killable.position = Vector3(5, 0, -10)
	add_child(killable)

	var walking = load("res://entities/walking_dummy.gd").new()
	walking.name = "WalkingDummy"
	walking.position = Vector3(15, 0, -10)
	walking.point_a = Vector3(15, 0, -10)
	walking.point_b = Vector3(15, 0, 10)
	add_child(walking)

# ── Lighting ──────────────────────────────────────────────────────────────────

func _build_lighting() -> void:
	# Sun and fill are created by LevelEnvironment.add_to in _build_environment;
	# kept as a hook for subclasses that re-style them (see dust2).
	pass


# ── Player ────────────────────────────────────────────────────────────────────

func _spawn_player(pid: int) -> CharacterBody3D:
	var player := CharacterBody3D.new()
	player.name = str(pid)
	player.set_multiplayer_authority(pid)
	
	# Use a slightly random spawn position to avoid exact overlapping
	player.position = Vector3(randf_range(-2, 2), 2.0, randf_range(-2, 2))
	
	# Server Synchronizer (Host is the ground truth)
	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 (Client dictates their aim and loadout setup)
	var client_sync = MultiplayerSynchronizer.new()
	client_sync.name = "MultiplayerSynchronizer" # Keep original name for compatibility if needed elsewhere
	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")
	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 ────────────────────────────────────────────────────────
	# Set references before the node enters the tree. Godot will call _ready() 
	# automatically when MultiplayerSpawner adds the node to the scene.
	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:
		# Disable physics processing/input for remote players
		# but keep _process enabled so synced state updates the HumanoidModel
		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. See the note in
# scenes/maps/level_runtime.gd: everything that describes A PLAYER belongs to
# ui/player_hud.gd, which that player spawns for itself.