class_name Player
extends CharacterBody3D


@export var camera_acceleration: float = 10.0 ## The acceleration used when lerping the camera position when crouching and standing
@export var crouch_height: float = 0.8 ## This should be where the head/camera would be located
@export var jump_count: int = 1 ## Number of jumps, reset when on the floor
@export var gravity: float = 9.8
@export var mouse_sensitivity: Vector2 = Vector2(0.1, 0.3) ## Horizontal and vertical mouse sensitivity
@export var standing_height: float = 1.8 ## This should be where the head/camera would be located

@export_group("Movement")
@export var acceleration: float = 10.0
@export var crouch_speed: float = 3.0
@export var jump_velocity: float = 4.5
@export var sprint_speed: float = 8.0
@export var sprint_toggle: bool = false ## Enables toggle sprint instead of hold. When enabled, sprinting will also be disabled when velocity is zero
@export var walk_speed: float = 5.0

@onready var head: Node3D = $Head
@onready var collision_shape_standing: CollisionShape3D = $CollisionShapeStanding
@onready var collision_shape_crouching: CollisionShape3D = $CollisionShapeCrouching
@onready var ray_cast_crouch: RayCast3D = $RayCastCrouch

var current_jump_count: int = 0
var current_speed: float = walk_speed
var direction: Vector3 = Vector3.ZERO
var is_crouching: bool = false
var is_sprinting: bool = false


func _input(event: InputEvent) -> void:
	if event is InputEventMouseMotion:
		_handle_mouse_movement(event.relative)

func _physics_process(delta: float) -> void:
	is_crouching = Input.is_action_pressed("crouch") or ray_cast_crouch.is_colliding()
	_set_is_sprinting()

	_apply_gravity(delta)
	_handle_jumping()

	_set_current_speed()
	_set_direction(delta)
	_handle_movement(delta)
	_handle_crouching(delta)

	move_and_slide()


func _apply_gravity(delta: float) -> void:
	if is_on_floor(): return
	velocity.y -= gravity * delta

## Toggle the crouching and standing collision shapes[br]
## Set the head height to the crouching or standing height
func _handle_crouching(delta: float) -> void:
	collision_shape_crouching.disabled = !is_crouching
	collision_shape_standing.disabled = is_crouching

	var height: float = crouch_height if is_crouching else standing_height
	head.position.y = lerp(head.position.y, height, camera_acceleration * delta)

func _handle_jumping() -> void:
	if is_on_floor():
		current_jump_count = 0

	if not is_on_floor() and current_jump_count >= jump_count:
		return
	elif Input.is_action_just_pressed("jump"):
		current_jump_count += 1
		velocity.y = jump_velocity

## Rotate the player and head to follow mouse movement
func _handle_mouse_movement(mouse_position: Vector2) -> void:
	rotate_y(deg_to_rad(-mouse_position.x * mouse_sensitivity.x)) # Rotate player horizontally
	head.rotate_x(deg_to_rad(-mouse_position.y * mouse_sensitivity.y)) # Rotate head vertically
	head.rotation.x = clamp(head.rotation.x, deg_to_rad(-90), deg_to_rad(90))

func _handle_movement(delta: float) -> void:
	if direction:
		velocity.x = direction.x * current_speed
		velocity.z = direction.z * current_speed
	else:
		velocity.x = move_toward(velocity.x, 0, current_speed * delta)
		velocity.z = move_toward(velocity.z, 0, current_speed * delta)

func _set_current_speed() -> void:
	if !is_on_floor(): return # Keep speed in air

	if is_crouching:
		current_speed = crouch_speed
	elif is_sprinting:
		current_speed = sprint_speed
	else:
		current_speed = walk_speed

func _set_direction(delta: float) -> void:
	var input_dir: Vector2 = Input.get_vector("move_left", "move_right", "move_forward", "move_backward")
	direction = lerp(
		direction,
		(transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized(),
		acceleration * delta
	)

func _set_is_sprinting() -> void:
	if is_crouching:
		is_sprinting = false
	elif sprint_toggle:
		if Input.is_action_just_pressed("run") and not is_sprinting:
			is_sprinting = true # Toggled sprint on
		elif Input.is_action_just_pressed("run") and is_sprinting:
			is_sprinting = false # Toggled sprint off
		elif velocity == Vector3.ZERO:
			is_sprinting = false
	else:
		is_sprinting = Input.is_action_pressed("run")