class_name GameBall extends RigidBody3D
## Base class for all gfolf balls

## Fired as soon as this ball enters a water hazard
signal entered_water

## Types of game balls
enum Type {
	NONE,
	BASIC,
	PLASMA,
	BRICK,
	BEACH,
	POWER,
}

const MAGNUS_SQ_EPSILON := 1e-3

## If enabled, ball ability cooldown is only reset at end of shot.
@export var once_per_shot_ability := false

## Material physics configuration for this ball.
@export var terrain_physics: TerrainPhysics

## Coefficient of the roll damping quadratic curve.
## This applies progressively greater damping after the ball rolls for a period of time.
@export var roll_damping_coefficient := 0.4

## Time in seconds after the ball begins rolling after which roll damping will start to apply.
## This applies progressively greater damping after the ball rolls for a period of time.
@export var roll_damping_delay := 12.0

## Coefficient of the roll cull linear curve.
## The ball be frozen if it rolls with speed under this curve.
@export var roll_cull_coefficient := 0.2

## Time in seconds after the ball begins rolling after which roll culling will start to apply.
@export var roll_cull_delay := 16.0

#@export var fluid_density := 1.225
#@export var lift_coefficient := 0.05
#@export var radius := 0.05
## Coefficient of angular velocity influence on linear velocity
## This is approximately 1/2 * rho * C_L * pi * r^2
## where `rho` is the fluid density of the medium, or 1.225 for air at sea level,
## and `C_L` is the lift coefficient which for our purposes is 0.05,
## and `r` is the radius of the ball, which is variable.
## NOTE: Rather than use r^2 we use r * a constant 0.05
#@export var magnus_coefficient := 0.00024
@export var magnus_coefficient := 0.00481056

## Causes the ball to stick to surfaces
@export var magnetic := false

## Base damage inflicted on impact with a player
@export var base_damage := 15.0

## Scaling factor for additional force-based damage
@export var damage_force_scale := 0.01

## Approximate average radius, for physics & positioning purposes
@export var radius := 0.05

var current_gravity: Vector3

var player: WorldPlayer

var _last_contact_normal: Vector3 = Vector3.UP
var _position_on_last_wake: Vector3
var _awake := false
var _ability_triggered := false
var _zones: Array[BallZone] = []
var _shot_time_s := 0.0
var _surface_time_s := 0.0
var _surface_terrain: Terrain.Type

@onready var ability_cooldown: Timer = %AbilityCooldown
@onready var manual_sleep_timer: Timer = %ManualSleepTimer
@onready var sfx: BallSFX = %SFX
@onready var effects: BallParticleEffects = %ParticleEffects

@onready var normal_physics: PhysicsMaterial = preload(
	"res://src/equipment/balls/physics_ball/normal_physics.tres"
)


## Should this ball stick to surfaces, rather than bounce?
func is_sticky() -> bool:
	return magnetic


## Called by a water area when this ball enters it
func enter_water() -> void:
	entered_water.emit()


## Activate this ball's ability, if there is one.
func activate_ability() -> void:
	if once_per_shot_ability:
		if not _ability_triggered:
			_ability_triggered = true
			_activate_ability()
		# TODO bonk
	elif ability_cooldown.is_stopped():
		_activate_ability()
		ability_cooldown.start()
	# TODO bonk


func _activate_ability() -> void:
	# Implmemented by derived type
	pass


func get_damage() -> float:
	print("velocity: ", linear_velocity.length())
	return base_damage + linear_velocity.length_squared() * damage_force_scale


func _magnus_force() -> Vector3:
	return magnus_coefficient * radius * angular_velocity.cross(linear_velocity)


func _integrate_forces(state: PhysicsDirectBodyState3D) -> void:
	current_gravity = state.total_gravity
	if not _awake:
		# Triggered on first frame after waking
		_awake = true
		_ability_triggered = false
		_position_on_last_wake = global_position
		_last_contact_normal = Vector3.UP
		_shot_time_s = 0.0
		_surface_time_s = 0.0
		# TODO something's fucky here... I think this gets called once after the ball sleeps

	if state.get_contact_count():
		# Ball is in contact with a surface

		# We want the contact normal which minimizes the angle to the up vector
		var min_dot := -1.0
		var primary_body: Node
		for i: int in range(state.get_contact_count()):
			var norm := state.get_contact_local_normal(i)
			var dot := norm.dot(Vector3.UP)
			if dot > min_dot:
				min_dot = dot
				_last_contact_normal = norm
				primary_body = state.get_contact_collider_object(i)
		_surface_terrain = Terrain.from_collision(global_position, primary_body)
	else:
		# Ball is in the air
		_surface_terrain = Terrain.Type.NONE
		_surface_time_s = 0.0

	var params := terrain_physics.get_params(_surface_terrain)
	angular_damp = params.angular_damp
	linear_damp = params.linear_damp

	# Progressively increase linear damping after a delay.
	linear_damp += roll_damping_coefficient * pow(maxf(_surface_time_s - roll_damping_delay, 0), 2)

	var cull_speed := roll_cull_coefficient * maxf(_surface_time_s - roll_cull_delay, 0)
	if linear_velocity.length_squared() < pow(cull_speed, 2):
		_manual_sleep()


func _physics_process(delta: float) -> void:
	# Simulate magnus effect
	var magnus := _magnus_force()
	if magnus.length_squared() > MAGNUS_SQ_EPSILON:
		apply_central_force(magnus)

	# Keep shot time
	_shot_time_s += delta
	_surface_time_s += delta


func enter_zone(zone: BallZone) -> void:
	_zones.push_back(zone)

	if zone.water_hazard:
		effects.play_splash()
		sfx.play_splash()
		entered_water.emit()


func exit_zone(zone: BallZone) -> void:
	_zones.erase(zone)


func get_reoriented_basis() -> Basis:
	var up := _last_contact_normal.normalized()
	var forward := (_position_on_last_wake - global_position).normalized()
	var right := up.cross(forward).normalized()
	forward = right.cross(up)  # orthonormalize
	return Basis(right, up, forward)


func _on_sleeping_state_changed() -> void:
	print("SLEEPING STATE: ", sleeping)
	if sleeping:
		# Trigger to reassign on wake
		_awake = false


func _manual_sleep() -> void:
	freeze = true
	linear_velocity = Vector3.ZERO
	angular_velocity = Vector3.ZERO
	manual_sleep_timer.start()


func _on_collision(body: Node) -> void:
	if is_sticky():
		# Freeze physics as soon as we hit something
		_manual_sleep()

	var terrain := Terrain.from_collision(global_position, body)
	print_debug("Collision terrain: ", Terrain.Type.keys()[terrain])

	if terrain:
		sfx.play_sfx(terrain)
		effects.play_effect(terrain)


func _fire_sleep_signal() -> void:
	sleeping = true
	sleeping_state_changed.emit()
