class_name Player extends RigidBody3D

var has_stage: bool = false:
	set(on_stage):
		print("%s player controller take stage" % "True: " if on_stage else "false")
		if has_stage != on_stage: 
			if on_stage:
				has_stage = true
				if is_inside_tree():
					camera.make_current()
					get_viewport().gui_release_focus()
					Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
					var jitter_tween: Tween = create_tween()
					jitter_tween.tween_property(self, "jitter_strength", 1, 1)
					if has_entered: emit_signal("ui_exited")
				elif has_stage:
					camera.current = true
					jitter_strength = 1
			else:
				if is_inside_tree() and has_stage:
					Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
					var jitter_tween: Tween = create_tween()
					jitter_tween.tween_property(self, "jitter_strength", 0, 0.5)
					if has_entered: emit_signal("ui_exited")
				else:
					jitter_strength = 0
				has_stage = false
		print("player controller %s take stage" % "did" if has_stage else "didn't")
		sleeping = has_stage

@export var mouse_sensitivity: Vector2 = Vector2(6, 5)

@export_range (0, 10) var max_speed: float = 3
@export_range (0, 10) var max_acceleration: float = 5
@export_range (0, 20) var damp: float = 10
@export_range (0.1, 1) var mouse_jerk:float = 0.5
@export_range (10, 100) var gamepad_response = 50
@export_range (50, 500) var mouse_jerk_rejection = 200
@export var max_angle:float = 75

@export var camera_jitter_speed:float = 3
@export var angular_jitter:Vector3 = Vector3(0.1, 0, 0.05)
@export var angular_jitter_speed:Vector3 = Vector3(2, 1, 1)
@export var location_jitter:Vector3 = Vector3(0.05, 0.05, 0.05)
@export var location_jitter_speed:Vector3 = Vector3(2, 0.3, 1)
var jitter_strength: float = 0

var loc_noise_spot: Vector3 = Vector3.ZERO
var rot_noise_spot: Vector3 = Vector3.ZERO

var rotation_speed: Vector2 = Vector2.ZERO
var current_mouse_rotation: Vector2 = Vector2.ZERO

var noise: Noise = FastNoiseLite.new()
var crouched:bool = false:
	set(set_crouching):
		if is_node_ready():
			if set_crouching and not crouched:
				$PlayerAnimationPlayer.play("crouch")
				crouched = set_crouching
			elif (not set_crouching and crouched) and not crouch_held:
				if can_stand_up():
					$PlayerAnimationPlayer.play("stand_up")
					crouch_toggled = false
					crouched = set_crouching
var on_crouch_cooldown:bool = false

@onready var yaw: Node3D = $Yaw
@onready var pitch: Node3D = $Yaw/Pitch
@onready var mount: Node3D = $Yaw/Pitch/Mount
@onready var camera: Camera3D = $Yaw/Pitch/Mount/Camera3D
@onready var focus_ray: RayCast3D = $Yaw/Pitch/Mount/Camera3D/RayCast3D
@onready var ui_prober: Area3D = $Yaw/Pitch/Mount/Camera3D/UiProber

@onready var base_fov = camera.fov
var zoomed:bool = false:
	set(zoom):
		if zoomed != zoom:
			if zoom:
				var zoom_tween = create_tween()
				zoom_tween.tween_property(camera, "fov", base_fov*0.5, 0.5)
			else:
				var zoom_tween = create_tween()
				zoom_tween.tween_property(camera, "fov", base_fov, 0.5)
		zoomed = zoom    
signal ui_entered
signal ui_exited

func _ready():
	_handle_jitter(0)
	ui_prober.area_entered.connect(_on_ray_entered)
	ui_prober.area_exited.connect(_on_ray_exited)
	$CrouchDetector.area_exited.connect(exit_crouch)
	
func _process(_delta):
	
	if has_stage:
		if has_entered:
			if focus_ray.get_collider() == null:
				pass
				#emit_signal("ui_exited")
				#dhas_entered = false    
			if Input.is_action_just_pressed("ui_accept"):
				State.pass_stage_to(focus_ray.get_collider())
		else:
			if Input.is_action_just_pressed("zoom_in_controller"):
				zoomed = true
			elif Input.is_action_just_released("zoom_in_controller"):
				zoomed = false

var has_entered:bool = false:
	set(val):
		if val != has_entered:
			if val:
				ui_entered.emit()
			else:
				ui_exited.emit()
		has_entered = val
		if not has_entered:
			delay_passed = false
var delay_passed:bool = false

func _on_ray_entered(_area):
	if not has_entered:
		var collision_object = focus_ray.get_collider()
		if collision_object is InteractiveSprite:
			
			has_entered = collision_object.try_reveal(self)
			
			await get_tree().create_timer(1.0).timeout
			if focus_ray.get_collider() is InteractiveSprite:
				delay_passed = true
			else:
				has_entered = false
		else:
			print("You are standing in front of a wall")

func _on_ray_exited(area):
	if delay_passed and area is InteractiveSprite:
		has_entered = false
	

func _physics_process(delta:float):
	if has_stage:
		_handle_movement(delta)
		_handle_rotation(delta)
	if jitter_strength > 0 and not State.reduce_motion: _handle_jitter(delta)

func _handle_movement(delta:float):
	var input:Vector2 = Vector2(Input.get_action_strength("player_right") - Input.get_action_strength("player_left"),
						Input.get_action_strength("player_backwards")*0.8 - Input.get_action_strength("player_forwards"))
	
	if input.length()>1:
		input = input.normalized()
	
	var direction: Vector3 = Vector3(input.x, 0, input.y)
	
	direction = yaw.global_transform.basis.x * direction.x + transform.basis.y * direction.y + yaw.global_transform.basis.z * direction.z        
	
	if linear_velocity.length() > (linear_velocity + (direction*max_speed - linear_velocity)).length():
		direction = Vector3.ZERO
	else:
		direction *= (direction*max_speed - linear_velocity).length()*max_acceleration
	
	linear_damp = damp * max(0.5, 1 - input.length())
	
	apply_central_impulse(direction*delta)

func _handle_rotation(delta:float):
	var smoothness = min(3, 60.0/Engine.get_frames_per_second())
	
	var input_speed = Vector2( Input.get_action_strength("look_right")-Input.get_action_strength("look_left"), Input.get_action_strength("look_up")-Input.get_action_strength("look_down")) * gamepad_response
	
	if current_mouse_rotation.length()>0:
		input_speed = current_mouse_rotation
		current_mouse_rotation = Vector2.ZERO
		
	rotation_speed = rotation_speed * (1-mouse_jerk*smoothness) + input_speed * mouse_jerk * smoothness
	
	if rotation_speed.y > 0 and pitch.rotation_degrees.x < 0:
		rotation_speed.y *= 1-pow(pitch.rotation_degrees.x/-max_angle, 4)
	elif rotation_speed.y < 0 and pitch.rotation_degrees.x > 0 :
		rotation_speed.y *= 1-pow(pitch.rotation_degrees.x/max_angle, 4)
	
	yaw.rotate_y(deg_to_rad(-rotation_speed.x * delta * mouse_sensitivity.x))
	pitch.rotate_x(deg_to_rad(-rotation_speed.y * delta * mouse_sensitivity.y))

func _handle_jitter(delta):
	loc_noise_spot += Vector3(delta * camera_jitter_speed * location_jitter_speed)
	rot_noise_spot += Vector3(delta * camera_jitter_speed * angular_jitter_speed)
	pitch.position = Vector3(
						noise.get_noise_1d(loc_noise_spot.x),
						noise.get_noise_1d(loc_noise_spot.y),
						noise.get_noise_1d(loc_noise_spot.z)
						) * location_jitter * jitter_strength
	
	if not State.reduce_motion: mount.rotation = Vector3(
						noise.get_noise_1d(rot_noise_spot.x),
						noise.get_noise_1d(rot_noise_spot.y),
						noise.get_noise_1d(rot_noise_spot.z)
						) * angular_jitter * jitter_strength
	

func _handle_mouse_input(event:InputEventMouseMotion):
	if event.relative.length() < mouse_jerk_rejection:
		current_mouse_rotation = event.relative

func _input(event:InputEvent):
	if Scenes.current_sequence != -1: return
	if has_stage and Scenes.current_sequence == -1:
		if event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:
			_handle_mouse_input(event)
			get_viewport().set_input_as_handled()
		if event is InputEventMouseButton and event.pressed:
			if Input.is_action_just_pressed("zoom_in_mouse"):
				zoomed = true
			elif Input.is_action_just_pressed("zoom_out_mouse"):
				zoomed = false
			
		if event.is_action_pressed("collect_memento_ui") or event.is_action_pressed("option_memento_ui"):
			if focus_ray.is_colliding():
				focus_ray.get_collider().handle(event)
				get_viewport().set_input_as_handled()
				
		if event.is_action_pressed("crouch"):
			cround_start_time = Time.get_unix_time_from_system()
			crouch_held = true
			if crouch_toggled:
				crouched = false
				#crouch_toggled is being released by crouch setter
			else:
				crouched = true

		if event.is_action_released("crouch"):
			crouch_held = false
			if Time.get_unix_time_from_system() > cround_start_time + 0.5:
				if crouched:
					crouched = false
			else:
				crouch_toggled = true

func play_scene(id: int, _repeat):
	if id == Scenes.id.YOUTH_DRAEVEN:
		var rotation_tween = create_tween()

func scene_finished(_id, repeat: bool):
	if repeat:
		State.take_stage(self, true)

var crouch_held: bool = false
var crouch_toggled: bool = false
var cround_start_time: float = 0
func _on_bed_enter(_body):
	return
	if not (crouched or on_crouch_cooldown):
		$PlayerAnimationPlayer.queue("crouch")
		var tween = create_tween()
		tween.tween_property(self, "max_speed", max_speed/2, 0.3)
		crouched = true

func _on_bed_exit(_body):
	return
	if crouched:
		crouched = false
		$PlayerAnimationPlayer.queue("stand_up")
		var tween = create_tween()
		tween.tween_property(self, "max_speed", max_speed*2, 1)
		
	on_crouch_cooldown = true
	await get_tree().create_timer(1.0).timeout
	on_crouch_cooldown = false

var inside_crouch_volume: Array[CrouchVolume] = []

#returns true, if the player character can stand upright.
func can_stand_up() -> bool:
	for area: Area3D in $CrouchDetector.get_overlapping_areas():
		if area is CrouchVolume:
			return false
	return true

func exit_crouch(body):
	if body is Area3D:
		crouched = false