use super::{
    CollisionContext, EnterContext, FighterStateImpl, InterruptContext, UpdateContext, ground,
};
use crate::fighter::animation::AnimKind;
use crate::fighter::state::FighterState;

#[derive(Debug, Clone, Hash)]
pub struct WaitState;

impl FighterStateImpl for WaitState {
    const NAME: &'static str = "Wait";
    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if let Some(state) = ground::grounded_movement_common_interrupts(state_context) {
            Some(state)
        } else if let Some(state) =
            ground::grounded_movement_standstill_common_interrupts(state_context)
        {
            // Don't transition into yourself
            if let FighterState::Wait(_) = state {
                None
            } else {
                Some(state)
            }
        } else {
            None
        }
    }

    fn on_enter(&mut self, state_context: &mut EnterContext) {
        state_context.play_animation(AnimKind::Wait, true);
    }

    fn update(&mut self, state_context: &mut UpdateContext) {
        ground::update_friction_motion(state_context);
    }

    fn check_collision_interrupt(
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
        ground::collision_interrupt(state_context, false)
    }

    fn is_visually_grounded<'a>(&'a self) -> bool {
        true
    }
}

pub fn check_input(state_context: &InterruptContext) -> Option<FighterState> {
    let input_frame = state_context.input.get_last_frame();

    if input_frame.movement.x.abs() < state_context.game_settings.input_common.stick_deadzone {
        return Some(FighterState::Wait(WaitState));
    }
    None
}