extends Path3D

@export_group("Train")
@export var train_speed: float = 6.0
@export var is_inmotion: bool = true
@export var train_model: PackedScene 
@export var axes_distance: float = 3.0 
@export var rail_distance: float = 1.2 
@export var cameras: Node3D 
@export_range(0.0, 1.0) var basic_swing: float = 0.1 

@export_group("Rails Bulding")
@export var sleepers_distance: float = 1.0
@export var sleepers_model: PackedScene 

@export_group("Manual Controls")
@export var speed_max: float = 15.0
@export var speed_min: float = -5.0 
@export var manual_acceleration: float = 5.0 

@export_group("Train Stops")
@export var enable_stops: bool = true
@export var stop_time: float = 4.0 
@export var brake_distance: float = 15.0 
@export var restart_time: float = 3.0 
@export var fireworks_scene: PackedScene 

var fireworks_colors: Array[Color] = [
	Color(1.0, 0.2, 0.2), # Rosso vivo
	Color(0.2, 1.0, 0.2), # Verde lime
	Color(0.3, 0.5, 1.0), # Blu cielo
	Color(1.0, 0.8, 0.1), # Oro
	Color(0.8, 0.2, 1.0), # Viola
	Color(0.1, 1.0, 0.9)  # Ciano
]

var train_instance: Node3D
var train_progress: float = 0.0
var swing_time: float = 0.0
var curve_roll: float = 0.0
var curve_pitch: float = 0.0

var stop_offset: Array[float] = []
var stops_position: Array[Vector3] = [] 
var stop_ongoing: bool = false
var next_stop_index: int = 0
var stop_multiply: float = 1.0
var is_restarting: bool = false
var tween_restart: Tween
var environment_config: EnvironmentConfig

func _ready() -> void:
	_cache_environment_config()
	if curve != null and curve.get_baked_length() > 0:
		build_rails()
		build_train()
		_plan_stops()
		_apply_initial_train_start()
	else:
		print("WARNING: Draw Path3D for rails!")

func _cache_environment_config() -> void:
	var parent_node: Node = get_parent()
	if parent_node != null:
		var day_night_node := parent_node.get_node_or_null("DayNight") as EnvironmentManagerRoot
		if day_night_node != null:
			environment_config = day_night_node.environment_config
			return

	var current_scene: Node = get_tree().current_scene
	if current_scene == null:
		return

	for child in current_scene.get_children():
		var environment_manager := child as EnvironmentManagerRoot
		if environment_manager != null:
			environment_config = environment_manager.environment_config
			return

func _apply_initial_train_start() -> void:
	if train_instance == null or curve == null:
		return

	var total_length: float = curve.get_baked_length()
	if total_length <= 0.0:
		return

	#start from a random position
	if environment_config != null and environment_config.train_start_from_random_position:
		train_progress = randf() * total_length
		_update_next_stop_index_from_progress()
	elif environment_config != null and not stop_offset.is_empty():
		#start from a specific stop
		var stop_index: int = clampi(environment_config.train_start_stop_index, 0, stop_offset.size() - 1)
		train_progress = stop_offset[stop_index]
		_set_next_stop_index_from_current(stop_index)
	else:
		train_progress = wrapf(train_progress, 0.0, total_length)
		_update_next_stop_index_from_progress()

	_snap_train_to_progress()

func _set_next_stop_index_from_current(current_stop_index: int) -> void:
	if stop_offset.is_empty():
		next_stop_index = 0
		return

	if train_speed >= 0.0:
		next_stop_index = (current_stop_index + 1) % stop_offset.size()
	else:
		next_stop_index = current_stop_index - 1
		if next_stop_index < 0:
			next_stop_index = stop_offset.size() - 1

func _update_next_stop_index_from_progress() -> void:
	if stop_offset.is_empty():
		next_stop_index = 0
		return

	if train_speed >= 0.0:
		next_stop_index = 0
		for i in range(stop_offset.size()):
			if stop_offset[i] > train_progress + 0.001:
				next_stop_index = i
				return
		return

	next_stop_index = stop_offset.size() - 1
	for i in range(stop_offset.size() - 1, -1, -1):
		if stop_offset[i] < train_progress - 0.001:
			next_stop_index = i
			return

func _snap_train_to_progress() -> void:
	if train_instance == null or curve == null:
		return

	var total_length: float = curve.get_baked_length()
	if total_length <= 0.0:
		return

	train_progress = wrapf(train_progress, 0.0, total_length)
	var center_position: Vector3 = to_global(curve.sample_baked(train_progress, true))
	var prog_forward: float = wrapf(train_progress + 2.0, 0.0, total_length)
	var forward_position: Vector3 = to_global(curve.sample_baked(prog_forward, true))

	train_instance.global_position = center_position
	if center_position.distance_to(forward_position) > 0.01:
		train_instance.look_at(forward_position, Vector3.UP)
		train_instance.rotate_y(PI)

	if cameras:
		cameras.global_position = center_position
		cameras.global_basis = train_instance.global_basis

func build_rails() -> void:
	var mat_wood = StandardMaterial3D.new()
	mat_wood.albedo_color = Color(0.35, 0.2, 0.1) 
	var mat_iron = StandardMaterial3D.new()
	mat_iron.albedo_color = Color(0.6, 0.6, 0.65) 
	mat_iron.metallic = 0.8
	
	var mesh_sleeper = BoxMesh.new()
	mesh_sleeper.size = Vector3(rail_distance + 0.6, 0.1, 0.3)
	var mesh_rail = BoxMesh.new()
	mesh_rail.size = Vector3(0.1, 0.15, sleepers_distance + 0.05) 
	
	var total_length = curve.get_baked_length()
	var piece_number = int(total_length / sleepers_distance)
	
	for i in range(piece_number):
		var distance = i * sleepers_distance
		var rail_piece = Node3D.new()
		add_child(rail_piece)
		
		var local_pos = curve.sample_baked(distance, true)
		var distance_forward = distance + 0.1
		var local_pos_forward = Vector3.ZERO
		
		if distance_forward > total_length:
			var pos_back = curve.sample_baked(distance - 0.1, true)
			local_pos_forward = local_pos + (local_pos - pos_back)
		else:
			local_pos_forward = curve.sample_baked(distance_forward, true)
			
		rail_piece.position = local_pos
		var global_pos = to_global(local_pos)
		var global_pos_forward = to_global(local_pos_forward)
		if global_pos.distance_to(global_pos_forward) > 0.001:
			rail_piece.look_at(global_pos_forward, Vector3.UP)
		
		if sleepers_model != null:
			var sleeper_custom = sleepers_model.instantiate()
			rail_piece.add_child(sleeper_custom)
		else:
			var sleeper = MeshInstance3D.new()
			sleeper.mesh = mesh_sleeper
			sleeper.material_override = mat_wood
			rail_piece.add_child(sleeper)
		
		var rail_sx = MeshInstance3D.new()
		rail_sx.mesh = mesh_rail
		rail_sx.material_override = mat_iron
		rail_sx.position = Vector3(-rail_distance / 2.0, 0.1, 0) 
		rail_piece.add_child(rail_sx)
		
		var rail_dx = MeshInstance3D.new()
		rail_dx.mesh = mesh_rail
		rail_dx.material_override = mat_iron
		rail_dx.position = Vector3(rail_distance / 2.0, 0.1, 0) 
		rail_piece.add_child(rail_dx)

func _plan_stops() -> void:
	var current_stops = []
	for child in get_children():
		if child is Marker3D:
			var offset = curve.get_closest_offset(child.position)
			current_stops.append({
				"offset": offset,
				"position": child.global_position 
			})
	current_stops.sort_custom(func(a, b): return a["offset"] < b["offset"])
	for data in current_stops:
		stop_offset.append(data["offset"])
		stops_position.append(data["position"])

func _input(event: InputEvent) -> void:
	if event is InputEventKey and event.pressed and not event.echo:
		if event.keycode == KEY_T:
			_goto_next_stop()
		elif event.keycode == KEY_F:
			_test_manual_fireworks()

func _test_manual_fireworks() -> void:
	if fireworks_scene == null or train_instance == null: return
		
	var firework_number = randi_range(5, 8)
	for i in range(firework_number):
		var fire_root = fireworks_scene.instantiate()
		get_tree().current_scene.add_child(fire_root)
		
		var offset_x = randf_range(-6.0, 6.0)
		var offset_z = randf_range(-6.0, 6.0)
		fire_root.global_position = train_instance.global_position + Vector3(offset_x, 0.5, offset_z)
		
		if fire_root.has_method("set_color"):
			fire_root.set_color(fireworks_colors.pick_random())
		if fire_root.has_method("turn_on"):
			fire_root.turn_on()
		
		await get_tree().create_timer(randf_range(0.2, 0.6)).timeout

func _goto_next_stop() -> void:
	if stop_offset.size() == 0 or stop_ongoing or is_restarting:
		return
	var target_offset = stop_offset[next_stop_index]
	train_progress = target_offset
	_execute_stop(train_speed >= 0)

func _physics_process(delta: float) -> void:
	input_controls_management(delta) 
	train_move(delta)

func input_controls_management(delta: float) -> void:
	if not is_inmotion: return
	if Input.is_action_pressed("ui_up"):
		train_speed += manual_acceleration * delta
	elif Input.is_action_pressed("ui_down"):
		train_speed -= manual_acceleration * delta
	elif Input.is_action_pressed("ui_text_backspace"):
		train_speed = 0
	train_speed = clamp(train_speed, speed_min, speed_max)

func train_move(delta: float) -> void:
	if is_inmotion and train_instance and curve:
		var total_length = curve.get_baked_length()
		if total_length <= 0: return
		
		if not stop_ongoing:
			var last_progress = train_progress
			
			if enable_stops and stop_offset.size() > 0 and not is_restarting:
				var target_offset = stop_offset[next_stop_index]
				var dist = target_offset - train_progress
				dist = wrapf(dist + total_length / 2.0, 0.0, total_length) - total_length / 2.0
				
				if abs(dist) < brake_distance and sign(dist) == sign(train_speed):
					var t = abs(dist) / brake_distance
					stop_multiply = max(smoothstep(0.0, 1.0, t), 0.05)
				else:
					stop_multiply = 1.0
			
			var current_speed = train_speed * stop_multiply
			train_progress += current_speed * delta
			
			if enable_stops and stop_offset.size() > 0:
				var target_offset = stop_offset[next_stop_index]
				var exceeded_forward = (current_speed > 0 and last_progress < target_offset and train_progress >= target_offset)
				var exceeded_back = (current_speed < 0 and last_progress > target_offset and train_progress <= target_offset)
				
				if exceeded_forward or exceeded_back:
					train_progress = target_offset 
					_execute_stop(current_speed > 0)
			
			if train_progress > total_length:
				train_progress -= total_length
				if stop_offset.size() > 0: next_stop_index = 0 
			elif train_progress < 0: 
				train_progress += total_length
				if stop_offset.size() > 0: next_stop_index = stop_offset.size() - 1
		
		var center_position = to_global(curve.sample_baked(train_progress, true))
		var prog_back = wrapf(train_progress - 2.0, 0.0, total_length)
		var back_position = to_global(curve.sample_baked(prog_back, true))
		var prog_forward = wrapf(train_progress + 2.0, 0.0, total_length)
		var forward_position = to_global(curve.sample_baked(prog_forward, true))

		if center_position.distance_to(forward_position) > 0.01:
			train_instance.global_position = center_position
			train_instance.look_at(forward_position, Vector3.UP)
			train_instance.rotate_y(PI) 
			
		if cameras:
			cameras.global_position = center_position
			cameras.global_basis = train_instance.global_basis
				
		var real_speed = abs(train_speed * stop_multiply)
		var speed_factor = clamp(real_speed / max(speed_max, 0.001), 0.0, 1.0)
		var dir_prev = (center_position - back_position).normalized()
		var dir_next = (forward_position - center_position).normalized()
		var signed_curve = dir_prev.cross(dir_next).y
		var curve_amount = clamp(abs(signed_curve) * 8.0, 0.0, 1.0)

		curve_roll = lerp(curve_roll, (-signed_curve * 0.08) * speed_factor, delta * 4.0)
		curve_pitch = lerp(curve_pitch, curve_amount * 0.012 * speed_factor, delta * 4.0)

		if not stop_ongoing:
			swing_time += delta * real_speed * (2.0 + curve_amount)
			var amplitude_z = 0.006 * basic_swing
			var amplitude_x = 0.004 * basic_swing
			var curve_sway = sin(swing_time * 1.35) * 0.01 * curve_amount * speed_factor
			train_instance.rotation.z += sin(swing_time) * amplitude_z
			train_instance.rotation.x += cos(swing_time * 0.8) * amplitude_x
			train_instance.rotation.z += curve_roll + curve_sway
			train_instance.rotation.x += curve_pitch
		else:
			train_instance.rotation.z += curve_roll
			train_instance.rotation.x += curve_pitch

func _execute_stop(go_forward: bool = true) -> void:
	stop_ongoing = true
	stop_multiply = 0.0 
	
	var current_stop_index = next_stop_index
	
	if go_forward:
		next_stop_index += 1
		if next_stop_index >= stop_offset.size():
			next_stop_index = 0 
	else:
		next_stop_index -= 1
		if next_stop_index < 0:
			next_stop_index = stop_offset.size() - 1
			
	if fireworks_scene != null:
		var marker_position = stops_position[current_stop_index]
		var firework_number = randi_range(5, 8)
		for i in range(firework_number):
			var fire_root = fireworks_scene.instantiate()
			get_tree().current_scene.add_child(fire_root)
			
			var offset_x = randf_range(-5.0, 5.0)
			var offset_z = randf_range(-5.0, 5.0)
			
			fire_root.global_position = marker_position + Vector3(offset_x, 0.5, offset_z)
			
			if fire_root.has_method("set_color"):
				fire_root.set_color(fireworks_colors.pick_random())
			if fire_root.has_method("turn_on"):
				fire_root.turn_on() 
				
			await get_tree().create_timer(randf_range(0.3, 0.8)).timeout
		
	await get_tree().create_timer(stop_time).timeout
	
	stop_ongoing = false
	is_restarting = true
	
	if tween_restart and tween_restart.is_valid():
		tween_restart.kill()
		
	tween_restart = create_tween()
	tween_restart.set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_IN_OUT)
	tween_restart.tween_property(self, "stop_multiply", 1.0, restart_time)
	tween_restart.tween_callback(func(): is_restarting = false)

func build_train() -> void:
	if train_model != null:
		train_instance = train_model.instantiate()
		add_child(train_instance)
	else:
		build_default_train()

func build_default_train() -> void:
	train_instance = Node3D.new()
	add_child(train_instance)
	
	var mat_body = StandardMaterial3D.new()
	mat_body.albedo_color = Color(0.8, 0.15, 0.15) 
	var mat_glass = StandardMaterial3D.new()
	mat_glass.albedo_color = Color(0.2, 0.8, 1.0) 
	
	var train_base = MeshInstance3D.new()
	var mesh_base = BoxMesh.new()
	mesh_base.size = Vector3(1.4, 0.8, 3.0)
	train_base.mesh = mesh_base
	train_base.material_override = mat_body
	train_base.position = Vector3(0, 0.6, 0) 
	train_instance.add_child(train_base)
	
	var cabin = MeshInstance3D.new()
	var mesh_cabin = BoxMesh.new()
	mesh_cabin.size = Vector3(1.4, 1.0, 1.2)
	cabin.mesh = mesh_cabin
	cabin.material_override = mat_glass
	cabin.position = Vector3(0, 1.5, -0.8) 
	train_instance.add_child(cabin)
	
	var stack = MeshInstance3D.new()
	var mesh_stack = CylinderMesh.new()
	mesh_stack.top_radius = 0.2
	mesh_stack.bottom_radius = 0.3
	mesh_stack.height = 0.8
	stack.mesh = mesh_stack
	stack.material_override = mat_body
	stack.position = Vector3(0, 1.2, 1.0)
	train_instance.add_child(stack)