bevy_input_bindings 0.0.2

use bevy::input::ButtonInput;
use bevy::input::keyboard::KeyCode;
use bevy::reflect::Reflect;
use std::time::Duration;

use crate::repeat::Repeat;

pub trait TriggerTrait {
    fn is_triggered(&mut self, button_input: &ButtonInput<KeyCode>, dt: &Duration) -> bool;
}

/// Triggers the action whenever the defined key has just been pressed
#[derive(Reflect, Clone, Debug)]
pub struct ButtonPressed {
    key: KeyCode,
    repeat: Option<Repeat>,
}

impl ButtonPressed {
    pub fn new(key: KeyCode) -> Self {
        Self {
            key,
            repeat: None,
        }
    }

    /// Repeat the trigger as long as the key is pressed, with delays between each actions.
    pub fn with_repeat(
        mut self,
        duration_before_first_repeat: Duration,
        duration_between_repeat: Duration,
    ) -> Self {
        self.repeat = Some(Repeat::new(duration_before_first_repeat, duration_between_repeat));
        self
    }
}

impl TriggerTrait for ButtonPressed {
    fn is_triggered(&mut self, button_input: &ButtonInput<KeyCode>, dt: &Duration) -> bool {
        let Some(repeat) = &mut self.repeat else {
            return button_input.just_pressed(self.key);
        };
        if button_input.just_pressed(self.key) {
            repeat.reset();
            return true;
        }
        let signal = button_input.pressed(self.key);
        return repeat.is_triggered(signal, dt);
    }
}

/// Triggers the action whenever the defined key has just been released
#[derive(Reflect, Clone, Debug)]
pub struct ButtonReleased {
    key: KeyCode,
}

impl ButtonReleased {
    pub fn new(key: KeyCode) -> Self {
        Self {
            key,
        }
    }
}

impl TriggerTrait for ButtonReleased {
    fn is_triggered(&mut self, button_input: &ButtonInput<KeyCode>, _dt: &Duration) -> bool {
        button_input.just_released(self.key)
    }
}