extends Node2D

@export var default_attack_time: float = 0.5
@export var default_damage: float = 5.0

@onready var trigger_area: Area2D = $TriggerArea
@onready var trigger_collision: CollisionShape2D = $TriggerArea/TriggerCollision
@onready var timer: Timer = $Timer
@onready var attack_path: Path2D = $AttackPath
@onready var path_follow_2d: PathFollow2D = $AttackPath/PathFollow2D
@onready var attack_area: Area2D = $AttackPath/PathFollow2D/Sprite2D/AttackArea

var damage: float
var current_target: Node2D = null
var current_progress: float = 0.0
var damaged_this_attack: Array = []

func _ready() -> void:
	attack_path.visible = false
	damage = default_damage
	

func _physics_process(delta: float) -> void:
	if timer.is_stopped():
		timer.start()
	if current_progress == 1.0:
		reset_attack()
	if current_target and is_instance_valid(current_target) and not current_target.is_queued_for_deletion():
		track_target(current_target)
		attack_path.visible = true

	# Do attack animation
	current_progress += delta / default_attack_time
	current_progress = clampf(current_progress, 0.0, 1.0)
	path_follow_2d.progress_ratio = current_progress

func reset_attack() -> void:
		current_target = null
		attack_path.visible = false
		current_progress = 0.0
		damaged_this_attack = []
		position = Vector2.ZERO
		rotation = 0.0

func set_target(body: Node2D):
	current_target = body

func track_target(body: Node2D):
	if not current_target or not is_instance_valid(body) or body.is_queued_for_deletion():
		print_debug("target deleted or queued for deletion")
		return
	var mid_distance = attack_path.curve.get_baked_length() / 2 
	var mid_point: Vector2 = attack_path.curve.sample_baked(mid_distance)
	var offset = body.global_position - to_global(mid_point)
	var desired_dir = (body.global_position - to_global(mid_point)).normalized()
	var start_point_global = attack_path.to_global(attack_path.curve.sample_baked(0))
	var end_point_global = attack_path.to_global(attack_path.curve.sample_baked(attack_path.curve.get_baked_length()))
	var curve_dir = (start_point_global - end_point_global).normalized()
	var angle_diff = curve_dir.angle_to(desired_dir)
	if rotation == 0.0:
		rotation = curve_dir.angle_to(desired_dir)
	print_debug("tracked target")
	position += offset

func _on_timer_timeout() -> void:
	if trigger_area.has_overlapping_bodies():
		for body in trigger_area.get_overlapping_bodies():
			if body.is_in_group(GlobalConst.GROUP_ENEMY):
				set_target(body)

func _on_attack_area_body_entered(body: Node2D) -> void:
	if not attack_path.visible:
		return
	if body in damaged_this_attack:
		return
	if body.is_in_group(GlobalConst.GROUP_ENEMY) and body.is_in_group(GlobalConst.GROUP_DAMAGEABLE):
		body.take_damage(damage)
		damaged_this_attack.append(body)