class_name CutsceneAnimationPlayer
extends AnimationPlayer


@export var camera: Camera3D
@export var player: PlayerCharacter
@export var end_alignment: Node3D
@export var cutscene_animation: StringName = &""
@export var auto_disable_flashlight: bool = true

var _original_camera: Camera3D
var _flashlight_was_active: bool = false


func play_cutscene() -> void:
	align_camera_with_view()
	play_with_capture(cutscene_animation)

	_original_camera = get_viewport().get_camera_3d()

	if auto_disable_flashlight:
		disable_flashlight()



func align_player_with_end_alignment() -> void:
	if not is_instance_valid(player) or not is_instance_valid(end_alignment):
		return

	player.align(end_alignment)


func lock_player() -> void:
	if is_instance_valid(player):
		player.set_physics_process(false)

		#player.process_mode = Node.PROCESS_MODE_DISABLED


func unlock_player() -> void:
	if is_instance_valid(player):
		player.set_physics_process(true)

		#player.process_mode = Node.PROCESS_MODE_INHERIT


func disable_flashlight() -> void:
	if is_instance_valid(player):
		_flashlight_was_active = player.flashlight.is_active
		player.flashlight.set_process_unhandled_input(false)
		player.flashlight.turn_off()


func restore_flashlight() -> void:
	if is_instance_valid(player):
		player.flashlight.set_process_unhandled_input(true)

		if _flashlight_was_active:
			player.flashlight.turn_on()


func interpolate_camera_back(duration: float = 0.5) -> void:
	if not is_instance_valid(camera) or not is_instance_valid(_original_camera):
		return

	var _interpolation_time: float = 0.0
	var _starting_transform: Transform3D = camera.global_transform
	var _starting_fov: float = camera.fov

	while _interpolation_time <= 1.0:
		if not is_inside_tree() or not is_instance_valid(_original_camera):
			return

		await RenderingServer.frame_pre_draw # For getting the actual camera effects on the player.

		var clamped_time: float = clampf(_interpolation_time, 0.0, 1.0)
		camera.global_transform = _starting_transform.interpolate_with(
				_original_camera.global_transform, clamped_time
		)
		camera.fov = lerpf(_starting_fov, _original_camera.fov, clamped_time)

		SPrint.print_msgf("Interpolation Time: %s" % clamped_time)
		SPrint.print_msgf("Camera Position: %s" % camera.global_position)
		SPrint.print_msgf("Camera Rotation: %s" % camera.global_rotation)
		SPrint.print_msgf("Camera FOV: %s" % camera.fov)
		SPrint.print_msgf("Original Camera Position: %s" % _original_camera.global_position)
		SPrint.print_msgf("Original Camera Rotation: %s" % _original_camera.global_rotation)
		_interpolation_time += get_process_delta_time() / maxf(duration, 0.001)
		await get_tree().process_frame


func align_camera_with_view() -> void:
	if not is_instance_valid(camera):
		return

	var current_camera: Camera3D = get_viewport().get_camera_3d()
	if is_instance_valid(current_camera):
		camera.global_transform = current_camera.global_transform
		camera.fov = current_camera.fov