StaminaSystem

extends Node
class_name StaminaSystem

enum StaminaType {
    MOVEMENT,  # Для спринта и перекатов
    DASH       # Для дэша
}

# Настройки стамины движения
@export var max_movement_stamina: float = 100.0
@export var movement_regeneration_rate: float = 20.0  # Стамины в секунду
@export var movement_regeneration_delay: float = 1.0  # Задержка после использования

# Настройки стамины дэша
@export var max_dash_stamina: float = 100.0
@export var dash_regeneration_rate: float = 15.0
@export var dash_regeneration_delay: float = 2.0

# Текущие значения
var current_movement_stamina: float
var current_dash_stamina: float
var last_movement_use_time: float = 0.0
var last_dash_use_time: float = 0.0

# Сигналы
signal stamina_changed(movement_stamina: float, dash_stamina: float)
signal movement_stamina_depleted
signal dash_stamina_depleted
signal stamina_used(amount: float, type: StaminaType)
signal stamina_restored(amount: float, type: StaminaType)

func _ready():
    current_movement_stamina = max_movement_stamina
    current_dash_stamina = max_dash_stamina
    stamina_changed.emit(current_movement_stamina, current_dash_stamina)

func _process(delta):
    # Регенерация стамины движения
    if should_regenerate_movement():
        regenerate_stamina(delta, StaminaType.MOVEMENT)

    # Регенерация стамины дэша
    if should_regenerate_dash():
        regenerate_stamina(delta, StaminaType.DASH)

func use_stamina(amount: float, type: StaminaType) -> bool:
    var current_stamina = get_current_stamina(type)

    if current_stamina < amount:
        return false

    match type:
        StaminaType.MOVEMENT:
            current_movement_stamina -= amount
            current_movement_stamina = max(current_movement_stamina, 0)
            last_movement_use_time = Time.get_ticks_msec() / 1000.0
            if current_movement_stamina <= 0:
                movement_stamina_depleted.emit()

        StaminaType.DASH:
            current_dash_stamina -= amount
            current_dash_stamina = max(current_dash_stamina, 0)
            last_dash_use_time = Time.get_ticks_msec() / 1000.0
            if current_dash_stamina <= 0:
                dash_stamina_depleted.emit()

    stamina_used.emit(amount, type)
    stamina_changed.emit(current_movement_stamina, current_dash_stamina)
    return true

func restore_stamina(amount: float, type: StaminaType) -> float:
    var max_stamina = get_max_stamina(type)
    var current_stamina = get_current_stamina(type)

    var old_stamina = current_stamina
    var new_stamina = min(current_stamina + amount, max_stamina)
    var actual_restore = new_stamina - old_stamina

    match type:
        StaminaType.MOVEMENT:
            current_movement_stamina = new_stamina
        StaminaType.DASH:
            current_dash_stamina = new_stamina

    if actual_restore > 0:
        stamina_restored.emit(actual_restore, type)
        stamina_changed.emit(current_movement_stamina, current_dash_stamina)

    return actual_restore

func can_use_stamina(amount: float, type: StaminaType) -> bool:
    return get_current_stamina(type) >= amount

func get_current_stamina(type: StaminaType) -> float:
    match type:
        StaminaType.MOVEMENT:
            return current_movement_stamina
        StaminaType.DASH:
            return current_dash_stamina
        _:
            return 0.0

func get_max_stamina(type: StaminaType) -> float:
    match type:
        StaminaType.MOVEMENT:
            return max_movement_stamina
        StaminaType.DASH:
            return max_dash_stamina
        _:
            return 0.0

func get_stamina_percentage(type: StaminaType) -> float:
    var max_stamina = get_max_stamina(type)
    if max_stamina <= 0:
        return 0.0
    return get_current_stamina(type) / max_stamina

func is_stamina_full(type: StaminaType) -> bool:
    return get_current_stamina(type) >= get_max_stamina(type)

func is_stamina_empty(type: StaminaType) -> bool:
    return get_current_stamina(type) <= 0

# Система регенерации
func should_regenerate_movement() -> bool:
    return (movement_regeneration_rate > 0 and
            not is_stamina_full(StaminaType.MOVEMENT) and
            Time.get_ticks_msec() / 1000.0 - last_movement_use_time >= movement_regeneration_delay)

func should_regenerate_dash() -> bool:
    return (dash_regeneration_rate > 0 and
            not is_stamina_full(StaminaType.DASH) and
            Time.get_ticks_msec() / 1000.0 - last_dash_use_time >= dash_regeneration_delay)

func regenerate_stamina(delta: float, type: StaminaType):
    var regen_rate = 0.0
    match type:
        StaminaType.MOVEMENT:
            regen_rate = movement_regeneration_rate
        StaminaType.DASH:
            regen_rate = dash_regeneration_rate

    var regen_amount = regen_rate * delta
    restore_stamina(regen_amount, type)

# Настройки стамины
func set_max_stamina(new_max: float, type: StaminaType, restore_to_full: bool = false):
    match type:
        StaminaType.MOVEMENT:
            var percentage = get_stamina_percentage(type) if not restore_to_full else 1.0
            max_movement_stamina = max(new_max, 1.0)
            current_movement_stamina = max_movement_stamina * percentage

        StaminaType.DASH:
            var percentage = get_stamina_percentage(type) if not restore_to_full else 1.0
            max_dash_stamina = max(new_max, 1.0)
            current_dash_stamina = max_dash_stamina * percentage

    stamina_changed.emit(current_movement_stamina, current_dash_stamina)

func set_regeneration_rate(new_rate: float, type: StaminaType):
    match type:
        StaminaType.MOVEMENT:
            movement_regeneration_rate = new_rate
        StaminaType.DASH:
            dash_regeneration_rate = new_rate

func set_regeneration_delay(new_delay: float, type: StaminaType):
    match type:
        StaminaType.MOVEMENT:
            movement_regeneration_delay = new_delay
        StaminaType.DASH:
            dash_regeneration_delay = new_delay

func restore_all_to_full():
    current_movement_stamina = max_movement_stamina
    current_dash_stamina = max_dash_stamina
    stamina_changed.emit(current_movement_stamina, current_dash_stamina)

func drain_all():
    current_movement_stamina = 0
    current_dash_stamina = 0
    stamina_changed.emit(current_movement_stamina, current_dash_stamina)
    movement_stamina_depleted.emit()
    dash_stamina_depleted.emit()

# Временные модификаторы (для будущих статусных эффектов)
var stamina_modifiers: Dictionary = {}

func add_stamina_modifier(id: String, movement_multiplier: float, dash_multiplier: float, duration: float = -1):
    stamina_modifiers[id] = {
        "movement_mult": movement_multiplier,
        "dash_mult": dash_multiplier,
        "duration": duration,
        "start_time": Time.get_ticks_msec() / 1000.0
    }

func remove_stamina_modifier(id: String):
    stamina_modifiers.erase(id)

func get_modified_regeneration_rate(type: StaminaType) -> float:
    var base_rate = movement_regeneration_rate if type == StaminaType.MOVEMENT else dash_regeneration_rate
    var multiplier = 1.0

    for modifier_id in stamina_modifiers:
        var modifier = stamina_modifiers[modifier_id]
        if modifier.duration > 0 and Time.get_ticks_msec() / 1000.0 - modifier.start_time > modifier.duration:
            stamina_modifiers.erase(modifier_id)
            continue

        if type == StaminaType.MOVEMENT:
            multiplier *= modifier.movement_mult
        else:
            multiplier *= modifier.dash_mult

    return base_rate * multiplier

# Сохранение/загрузка
func get_save_data() -> Dictionary:
    return {
        "current_movement_stamina": current_movement_stamina,
        "current_dash_stamina": current_dash_stamina,
        "max_movement_stamina": max_movement_stamina,
        "max_dash_stamina": max_dash_stamina,
        "movement_regeneration_rate": movement_regeneration_rate,
        "dash_regeneration_rate": dash_regeneration_rate
    }

func load_save_data(data: Dictionary):
    current_movement_stamina = data.get("current_movement_stamina", max_movement_stamina)
    current_dash_stamina = data.get("current_dash_stamina", max_dash_stamina)
    max_movement_stamina = data.get("max_movement_stamina", 100.0)
    max_dash_stamina = data.get("max_dash_stamina", 100.0)
    movement_regeneration_rate = data.get("movement_regeneration_rate", 20.0)
    dash_regeneration_rate = data.get("dash_regeneration_rate", 15.0)
    stamina_changed.emit(current_movement_stamina, current_dash_stamina)