extends CharacterBody3D
class_name CharacterWrapper

@export var die_script: GDScript = null
@export var owner_placeholder: CharacterBody3D = null

@export var interpolation_speed: float = 50.0  # How quickly the model corrects position
@export var velocity_influence: float = 1.0  # How much velocity is used for smoothing
@export var snap_threshold: float = 2.0  # If desync is larger than this, snap faster

@export var interpolation_delay: float = 0.1  # Stay 100ms behind for smooth interpolation
var previous_server_pos: Vector3 = Vector3.ZERO
var position_buffer = []  # Stores past positions (tuples of (timestamp, position))
func _process(delta):
	# Record the latest server position with timestamp
	position_buffer.append([Time.get_ticks_msec() / 1000.0, owner_placeholder.global_transform.origin])
	# Remove old positions to keep buffer clean
	while position_buffer.size() > 2 and position_buffer[1][0] < (Time.get_ticks_msec() / 1000.0) - interpolation_delay:
		position_buffer.pop_front()
	# If we have at least 2 points, interpolate between them
	if position_buffer.size() >= 2:
		var t_now = (Time.get_ticks_msec() / 1000.0) - interpolation_delay
		var prev_point = position_buffer[0]
		var next_point = position_buffer[1]
		# Find the interpolation factor (how far we are between these two points)
		var alpha = (t_now - prev_point[0]) / (next_point[0] - prev_point[0])
		alpha = clamp(alpha, 0.0, 1.0)  # Prevent weird values
		
		# Lerp between the two closest timestamps
		global_transform.origin = prev_point[1].lerp(next_point[1], alpha)
# Called when the node enters the scene tree for the first time.
func _ready() -> void:
	set_multiplayer_authority(multiplayer.get_unique_id())
	global_position = owner_placeholder.global_position
	
#func _physics_process(delta: float) -> void:
	##if not is_on_floor():
		##velocity += get_gravity() * delta
	##global_position = owner_placeholder.global_position
		#
	#var server_pos = owner_placeholder.global_transform.origin
	#var server_velocity = (server_pos - previous_server_pos) / delta
	#
	#if server_velocity.length() < 0.1:
		#velocity = Vector3.ZERO  # Stop predicting movement when nearly still
	#var distance_to_server = global_transform.origin.distance_to(server_pos)
	#if distance_to_server > snap_threshold:
		## If the desync is too large, quickly correct it
		#global_transform.origin = server_pos
	#else:
		## Otherwise, smoothly adjust position
		#global_transform.origin = global_transform.origin.lerp(server_pos, interpolation_speed * delta)
	#
	#global_transform.origin += velocity * velocity_influence * delta
	## Update stored velocity
	#velocity = velocity.lerp(server_velocity, delta * interpolation_speed)
	#previous_server_pos = server_pos
	##velocity = owner_placeholder.velocity
	##global_transform.origin = global_transform.origin.lerp(server_pos, interpolation_speed * delta)
	##global_transform.origin += velocity * velocity_influence * delta
	##velocity = velocity.lerp(server_velocity, delta * interpolation_speed)
	#move_and_slide()

# Set the owner placeholder, so the characters can send the requests to a node
# it depends on
func set_owner_placeholder(owner_placeholder: Node3D):
	owner_placeholder = owner_placeholder
	
func die():
	push_warning("TODO: Implement ragdoll kind of dying and respawn character as an object")
	queue_free()


func _on_area_body_part_hit(damage: int) -> void:
	# The owner node should be aware of how to take damage, so we need to
	# pass the value.
	if owner_placeholder:
		if owner_placeholder.has_method("take_damage"):
			owner_placeholder.take_damage(damage)
		else:
			push_warning("Node doesn't know how to take the damage")