class_name MinionBehavior
extends Node

## 小怪行为状态机（关卡设计指南 §7.4 / AnchorV1.0 §17.5）。
## 近战怪：入场 → 巡逻 → （警戒后在下一个节拍点）追击 → 攻击。
## 远程怪：入场 → 移动到站位固定 → 距离判断攻击；被近身或连续受击时后撤。
## 决策与攻击都对齐节拍；移动逐帧执行。

const ROLE_MELEE := &"melee"
const ROLE_RANGED := &"ranged"

const STATE_ENTRY := &"Entry"
const STATE_PATROL := &"Patrol"
const STATE_CHASE := &"Chase"
const STATE_HOLD := &"Hold"
const STATE_RETREAT := &"Retreat"

@export var enabled := true
## 近战怪会巡逻并追击；远程怪固定站位、会后撤。
@export var role: StringName = ROLE_MELEE
@export var target_path: NodePath
@export var enemy_action_driver_path: NodePath = NodePath("../EnemyActionDriver")
@export var action_controller_path: NodePath = NodePath("../ActionController")
@export var health_component_path: NodePath = NodePath("../HealthComponent")
## Attacks only start inside this horizontal distance; further away the minion
## repositions instead (near for melee, the whole firing lane for ranged).
## new3 §4.2：近战攻击距离 120。
@export var attack_range := 120.0
## Stop approaching a little inside the attack range so the minion does not
## rub against the player collider. new3 §4.2：追踪停止距离 120。
@export var approach_stop_range := 120.0
## 警戒范围：玩家进入后近战怪转入追击（下一个节拍点生效）。new3 §4.2：360。
@export var alert_range := 360.0
## 近战怪巡逻半径与速度（占 approach_speed 的比例）。
@export var patrol_radius := 110.0
@export var patrol_speed_scale := 0.45
## 远程怪后撤参数（new3 §5.4）：玩家进入危险距离时向后退开。
@export var retreat_distance := 220.0
@export var retreat_speed_scale := 1.7
@export var too_close_range := 220.0
@export var too_close_seconds := 0.6
## 受击脱离（2026-07-05 定案）：连续受击 4 次触发短暂闪烁无敌 + 跳跃形式脱离。
@export var retreat_after_hits := 4
@export var hit_chain_window_seconds := 2.0
@export var retreat_cooldown_seconds := 3.0
@export var escape_invuln_seconds := 0.4
@export var escape_speed_scale := 3.2
## 后撤/脱离结束后的停顿（按节拍对齐，new3 §5.4 推荐 0.4s ≈ 1 拍）。
@export var post_retreat_pause_beats := 1
## 可活动区间：巡逻 / 后撤永远不出这段地面。
@export var arena_min_x := 1120.0
@export var arena_max_x := 2890.0
## 增援入场目标（NAN = 原地即战斗区域，直接进入巡逻/站位）。
@export var entry_target_x := NAN

@onready var driver: Node = get_node_or_null(enemy_action_driver_path)
@onready var action_controller: Node = get_node_or_null(action_controller_path)
@onready var health_component: Node = get_node_or_null(health_component_path)
@onready var target: Node2D = get_node_or_null(target_path) as Node2D

var state: StringName = STATE_ENTRY
var _next_decision_beat := 0
var _action_index := 0
var _patrol_anchor_x := 0.0
var _patrol_direction := 1.0
var _chase_pending := false
var _retreat_target_x := 0.0
var _too_close_time := 0.0
var _recent_hits := 0
var _hit_window_left := 0.0
var _retreat_cooldown_left := 0.0
var _escaping := false
var _invuln_left := 0.0


func _ready() -> void:
	var bus := _event_bus_or_null()
	if bus != null and bus.has_signal("beat_ticked") and not bus.is_connected("beat_ticked", _on_beat_ticked):
		bus.connect("beat_ticked", _on_beat_ticked)
	var receiver := get_node_or_null("../DamageReceiver")
	if receiver != null and receiver.has_signal("damage_received") and not receiver.is_connected("damage_received", _on_damage_received):
		receiver.connect("damage_received", _on_damage_received)
	_patrol_anchor_x = _owner_x()
	_refresh_target()
	if _has_entry_move():
		state = STATE_ENTRY
	else:
		state = STATE_PATROL if role == ROLE_MELEE else STATE_HOLD
	_face_target()


func _exit_tree() -> void:
	var bus := _event_bus_or_null()
	if bus != null and bus.has_signal("beat_ticked") and bus.is_connected("beat_ticked", _on_beat_ticked):
		bus.disconnect("beat_ticked", _on_beat_ticked)


func _physics_process(delta: float) -> void:
	_tick_escape_invulnerability(delta)
	if not enabled or _is_dead():
		_set_approach_direction(0.0)
		return
	if action_controller != null and int(action_controller.get("phase")) != 0:
		# 攻击动作进行中：位移交给动作本身。
		_set_approach_direction(0.0)
		return
	_refresh_target()
	_tick_retreat_triggers(delta)
	_update_state()
	_update_movement()


## ------------------------------------------------------- state transitions


func _update_state() -> void:
	var distance := _distance_to_target()
	match state:
		STATE_ENTRY:
			# 近战怪的入场可以被警戒打断（追击等下一拍）；远程怪坚持走到站位。
			# 每帧重算：玩家在下一拍前离开警戒范围就不再追。
			if role == ROLE_MELEE:
				_chase_pending = distance <= alert_range
			if _entry_reached():
				_arrive_at_battle_area()
		STATE_PATROL:
			_chase_pending = distance <= alert_range
		STATE_CHASE:
			if distance > alert_range * 1.25:
				# 玩家甩开警戒范围：回到当前位置附近小范围巡逻。
				state = STATE_PATROL
				_patrol_anchor_x = _owner_x()
				_chase_pending = false
		STATE_HOLD:
			if _should_escape():
				_begin_escape()
			elif _should_retreat(distance):
				_begin_retreat()
		STATE_RETREAT:
			if absf(_owner_x() - _retreat_target_x) <= 10.0:
				_finish_retreat()


func _arrive_at_battle_area() -> void:
	entry_target_x = NAN
	if role == ROLE_MELEE:
		state = STATE_PATROL
		_patrol_anchor_x = _owner_x()
	else:
		# 到达站位后固定下来，开始距离判断。
		state = STATE_HOLD


func _begin_retreat(escape := false) -> void:
	var own_x := _owner_x()
	var away := 1.0
	if target != null and is_instance_valid(target):
		away = 1.0 if own_x >= target.global_position.x else -1.0
	var candidate := clampf(own_x + away * retreat_distance, arena_min_x, arena_max_x)
	if absf(candidate - own_x) < 60.0:
		# 贴墙没有退路：跳向另一侧（穿过玩家身位）。
		candidate = clampf(own_x - away * retreat_distance, arena_min_x, arena_max_x)
	_retreat_target_x = candidate
	_too_close_time = 0.0
	_recent_hits = 0
	_retreat_cooldown_left = retreat_cooldown_seconds
	_escaping = escape
	if escape:
		_start_escape_invulnerability()
	state = STATE_RETREAT


## 受击脱离（2026-07-05 定案）：短暂闪烁无敌 + 跳跃形式快速脱离。
func _begin_escape() -> void:
	_begin_retreat(true)


func _finish_retreat() -> void:
	state = STATE_HOLD
	_escaping = false
	# 后撤/脱离后的短暂停顿：按节拍推迟下一次攻击决策（new3 §5.4）。
	_next_decision_beat = maxi(_next_decision_beat, _current_beat_index() + maxi(0, post_retreat_pause_beats) + 1)


func _should_retreat(distance: float) -> bool:
	if role != ROLE_RANGED or _retreat_cooldown_left > 0.0:
		return false
	return _too_close_time >= too_close_seconds


func _should_escape() -> bool:
	if role != ROLE_RANGED or _retreat_cooldown_left > 0.0:
		return false
	return _recent_hits >= maxi(1, retreat_after_hits)


func _start_escape_invulnerability() -> void:
	_invuln_left = maxf(0.0, escape_invuln_seconds)
	_set_damage_receiver_enabled(false)


func _tick_escape_invulnerability(delta: float) -> void:
	if _invuln_left <= 0.0:
		return
	_invuln_left = maxf(0.0, _invuln_left - delta)
	var visual := _owner_visual()
	if _invuln_left <= 0.0:
		if visual != null:
			visual.modulate.a = 1.0
		if not _is_dead():
			_set_damage_receiver_enabled(true)
		return
	if visual != null:
		# 闪烁表现：无敌期间快速明暗交替。
		visual.modulate.a = 0.35 if fmod(_invuln_left, 0.16) > 0.08 else 1.0


## FrameCollisionDriver 每物理帧都会重申受击矩阵，所以无敌必须通过它的
## damage_receiver_enabled 开关实现，而不是直接改 Area2D 的 monitoring。
func _set_damage_receiver_enabled(enabled: bool) -> void:
	var collision_driver := get_node_or_null("../FrameCollisionDriver")
	if collision_driver != null and "damage_receiver_enabled" in collision_driver:
		collision_driver.set("damage_receiver_enabled", enabled)
	var receiver := get_node_or_null("../DamageReceiver") as Area2D
	if receiver != null:
		receiver.set_deferred("monitoring", enabled)
		receiver.set_deferred("monitorable", enabled)


func _owner_visual() -> Node2D:
	var owner := get_parent()
	if owner == null:
		return null
	return owner.get_node_or_null("Visual") as Node2D


func _current_beat_index() -> int:
	var rhythm := get_tree().root.get_node_or_null("RhythmManager") if is_inside_tree() else null
	if rhythm != null:
		return int(rhythm.get("beat_index"))
	return 0


func _tick_retreat_triggers(delta: float) -> void:
	_retreat_cooldown_left = maxf(0.0, _retreat_cooldown_left - delta)
	if _hit_window_left > 0.0:
		_hit_window_left = maxf(0.0, _hit_window_left - delta)
		if _hit_window_left <= 0.0:
			_recent_hits = 0
	if role == ROLE_RANGED and state == STATE_HOLD and _distance_to_target() <= too_close_range:
		_too_close_time += delta
	else:
		_too_close_time = maxf(0.0, _too_close_time - delta * 2.0)


func _on_damage_received(_amount: int, _hit_type: StringName, _from: Vector2) -> void:
	if role != ROLE_RANGED:
		return
	if _hit_window_left <= 0.0:
		_recent_hits = 0
	_recent_hits += 1
	_hit_window_left = hit_chain_window_seconds


## --------------------------------------------------------------- movement


func _update_movement() -> void:
	match state:
		STATE_ENTRY:
			_move_toward_x(entry_target_x, 1.0)
		STATE_PATROL:
			_patrol_step()
		STATE_CHASE:
			_chase_step()
		STATE_HOLD:
			_set_approach_direction(0.0)
			_face_target()
		STATE_RETREAT:
			_move_toward_x(_retreat_target_x, escape_speed_scale if _escaping else retreat_speed_scale)
			_face_target()


func _patrol_step() -> void:
	var own_x := _owner_x()
	var half := maxf(20.0, patrol_radius)
	var low := clampf(_patrol_anchor_x - half, arena_min_x, arena_max_x)
	var high := clampf(_patrol_anchor_x + half, arena_min_x, arena_max_x)
	if own_x <= low:
		_patrol_direction = 1.0
	elif own_x >= high:
		_patrol_direction = -1.0
	_set_approach_direction(_patrol_direction * patrol_speed_scale)
	_face_walk_direction(_patrol_direction)


func _chase_step() -> void:
	var owner := get_parent() as Node2D
	if owner == null or target == null or not is_instance_valid(target):
		_set_approach_direction(0.0)
		return
	var delta_x := target.global_position.x - owner.global_position.x
	if absf(delta_x) <= maxf(8.0, approach_stop_range):
		_set_approach_direction(0.0)
	else:
		_set_approach_direction(signf(delta_x))
	_face_target()


func _move_toward_x(target_x: float, speed_scale: float) -> void:
	if is_nan(target_x):
		_set_approach_direction(0.0)
		return
	var delta_x := target_x - _owner_x()
	if absf(delta_x) <= 8.0:
		_set_approach_direction(0.0)
		return
	_set_approach_direction(signf(delta_x) * speed_scale)
	if state == STATE_ENTRY:
		_face_walk_direction(signf(delta_x))


func _entry_reached() -> bool:
	return not _has_entry_move() or absf(entry_target_x - _owner_x()) <= 10.0


func _has_entry_move() -> bool:
	return not is_nan(entry_target_x)


func _set_approach_direction(direction: float) -> void:
	var owner := get_parent()
	if owner != null and "approach_direction" in owner:
		owner.set("approach_direction", direction)


## ------------------------------------------------------------ beat driven


func _on_beat_ticked(beat_index: int) -> void:
	if not enabled or _is_dead():
		return
	if _chase_pending and role == ROLE_MELEE and state != STATE_CHASE:
		# 指南 §7.4：警戒后在下一个节拍点进入追击状态。
		_chase_pending = false
		state = STATE_CHASE
	if action_controller != null and int(action_controller.get("phase")) != 0:
		return
	if beat_index < _next_decision_beat:
		return
	if state == STATE_ENTRY or state == STATE_RETREAT:
		return
	var owner := get_parent()
	if owner == null or not owner.has_method("current_action_ids"):
		return
	_refresh_target()
	if _distance_to_target() > attack_range:
		# Out of reach: keep repositioning (handled per-frame); re-check next beat.
		_next_decision_beat = beat_index + 1
		return
	_face_target()
	var action_ids: Array = owner.call("current_action_ids")
	if action_ids.is_empty():
		return
	var action_id := StringName(str(action_ids[_action_index % action_ids.size()]))
	_action_index += 1
	var interval := 1
	if owner.has_method("current_attack_interval_beats"):
		interval = maxi(1, int(owner.call("current_attack_interval_beats")))
	_next_decision_beat = beat_index + interval
	if driver != null and driver.has_method("start_action"):
		driver.call("start_action", action_id)


## ----------------------------------------------------------------- lookup


func _distance_to_target() -> float:
	var owner := get_parent() as Node2D
	if owner == null or target == null or not is_instance_valid(target):
		return INF
	return absf(target.global_position.x - owner.global_position.x)


func _owner_x() -> float:
	var owner := get_parent() as Node2D
	return owner.global_position.x if owner != null else 0.0


func _refresh_target() -> void:
	if target != null and is_instance_valid(target):
		return
	target = get_node_or_null(target_path) as Node2D
	if target != null:
		return
	var owner := get_parent()
	if owner == null or owner.get_parent() == null:
		return
	target = owner.get_parent().get_node_or_null("Player") as Node2D


func _face_target() -> void:
	var owner := get_parent()
	if target != null and owner != null and owner.has_method("look_at_target"):
		owner.call("look_at_target", target)


func _face_walk_direction(direction: float) -> void:
	var owner := get_parent()
	if owner == null or is_zero_approx(direction):
		return
	if "heading" in owner:
		owner.set("heading", Vector2.LEFT if direction < 0.0 else Vector2.RIGHT)


func _is_dead() -> bool:
	if health_component != null and int(health_component.get("current")) <= 0:
		return true
	var owner := get_parent()
	if owner == null:
		return false
	var state_machine := owner.get_node_or_null("StateMachine")
	if state_machine != null and state_machine.has_method("build_context"):
		return StringName(str(state_machine.call("build_context").get("life_state", &"Alive"))) == &"Dead"
	return false


func _event_bus_or_null() -> Node:
	if not is_inside_tree():
		return null
	return get_tree().root.get_node_or_null("EventBus")