extends Node
class_name State

###
# flags and variables here
@export var state_priority: int
@export var animation_name: String
@export var animation_speed_scale := 1.0
@export var cooldown_time := 0.0
@export var stamina_toll := 0.0
@export var energy_toll := 0.0
@export var transition_to_self := false

var player: Player
var state_finished: bool
var enter_state_time: float
var exit_state_time: float = 0
var animation_finished: bool

var has_queued_state: bool
var queued_state_name: String


# this should be filled out before states are deployed!
var states: Dictionary


func states_priority_sort(a: String, b: String):
	var state_a: State = states.get(a)
	var state_b: State = states.get(b)
	
	if not state_a:
		print_debug("Unrecognized state: " + a)
	if not state_b:
		print_debug("Unrecognized state: " + b)

	var priority_a: int = state_a.state_priority if state_a else -1
	var priority_b: int = state_b.state_priority if state_b else -1
	return priority_a > priority_b


func should_enter(input: InputPacket) -> String:
	input.player_actions.sort_custom(states_priority_sort)
	return input.player_actions[0]


func update(_input: InputPacket, delta: float):
	regain_stamina(delta)
	pass


func on_enter_state():
	pass


func on_exit_state():
	pass


func mark_enter_state():
	enter_state_time = Time.get_unix_time_from_system()


func mark_exit_state():
	exit_state_time = Time.get_unix_time_from_system()


func get_remaining_cooldown_time() -> float:
	if cooldown_time <= 0:
		return 0

	var time_since_exit := Time.get_unix_time_from_system() - exit_state_time
	if time_since_exit >= cooldown_time:
		return 0
	else:
		return cooldown_time - time_since_exit


func get_progress() -> float:
	var now := Time.get_unix_time_from_system()
	return now - enter_state_time


func _when_animation_started(_anim_name: StringName):
	animation_finished = false


func _when_animation_finished(_anim_name: StringName):
	animation_finished = true


func check_combos(input: InputPacket):
	for node in get_children():
		if node is Combo:
			if node.is_triggered(input):
				queued_state_name = node.triggered_state_name
				has_queued_state = true


func ok_to_queue_next_state() -> bool:
	return player.model.skeleton.queue_next_state


func ok_to_transition_to_queued_state():
	return player.model.skeleton.transition_to_queued_state


func react_to_hit(hit: HitPacket):
	print(player.name + " got hit by " + hit.weapon.equipped_by.name)
	
	# increase energy for the player who did the hit
	hit.weapon.equipped_by.energy_points = min(
		hit.weapon.equipped_by.energy_points + hit.weapon.energy_return_on_hit,
		player.max_energy_points
		)
	
	# manage hit points
	player.hit_points = max(
		player.hit_points - hit.base_damage,
		0
		)

	# choose state based on HP
	if player.hit_points > 0:
		queued_state_name = "Hit"
	else:
		queued_state_name = "Death"
	has_queued_state = true


func is_attacking() -> bool:
	return player.model.skeleton.is_attacking


func regain_stamina(delta: float):
	if player.stamina_points < player.max_stamina_points:
		player.stamina_points += player.stamina_regain_per_sec * delta
		if player.stamina_points > player.max_stamina_points:
			player.stamina_points = player.max_stamina_points