use bevy::log::error;

use crate::fighter::{
    FighterId, attack::{AttackKind, FighterAttackScriptAssets, update_active_hitbox_list}, state::{
        CollisionContext, EnterContext, ExitContext, FighterState, FighterStateImpl, InterruptContext, UpdateContext, air::{self, AirborneStateCommon}, fall::FallState, wait::WaitState,
    },
};

#[derive(Clone, Debug, Hash)]
pub struct AirAttackState {
    pub attack_kind: AttackKind,
    pub airborne_state_common: AirborneStateCommon
}

impl FighterStateImpl for AirAttackState {
    const NAME: &'static str = "AirAttack";

    fn check_interrupt(&self, state_context: &mut InterruptContext) -> Option<FighterState> {
        if state_context.is_current_animation_finished() {
            Some(FighterState::Fall(FallState::new(self.airborne_state_common)))
        } else {
            None
        }
    }

    fn update(&mut self, state_context: &mut UpdateContext) {
        let animation_frame = state_context.get_current_animation_frame();
        let script = state_context
            .attack_scripts
            .get(&state_context.attack_script_assets.scripts[&self.attack_kind]);
        if let Some(script) = script {
            update_active_hitbox_list(
                script,
                &mut state_context
                    .hitboxes
                    .0
                    .as_mut()
                    .expect("ground attack must have active hitboxes")
                    .active_hitboxes,
                animation_frame,
            );
        }

        air::update_standard_motion(state_context, &mut self.airborne_state_common);
    }

    fn on_enter(&mut self, state_context: &mut EnterContext) {
        state_context.play_animation(self.attack_kind.get_animation(), false);
        let script = state_context.attack_script_assets.scripts[&self.attack_kind].clone();
        state_context.hitboxes.0 = Some(crate::fighter::FighterActiveAttack {
            kind: self.attack_kind,
            script,
            active_hitboxes: Vec::new(),
            solved_hitboxes: Vec::new(),
            hit_fighters: Vec::new(),
            stalled: false,
        });
    }

    fn on_exit(&mut self, state_context: &mut ExitContext) {
        state_context.hitboxes.0 = None;
    }

    fn check_collision_interrupt(
        &mut self,
        state_context: &mut CollisionContext,
    ) -> Option<FighterState> {
        air::collision_interrupt(
            state_context,
            crate::fighter::state::land::LandingType::Normal,
            false,
        )
    }

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

#[derive(thiserror::Error, Debug)]
pub enum AirAttackStateCreateError {
    #[error("Attack script: {attack:?} not found")]
    AttackScriptNotFound{attack: AttackKind},
}

impl AirAttackState {
    pub fn create(attack_kind: AttackKind, attack_script_assets: &FighterAttackScriptAssets, airborne_state_common: &AirborneStateCommon) -> Result<Self, AirAttackStateCreateError> {
        if attack_script_assets.scripts.contains_key(&attack_kind) {
            Ok(AirAttackState {
                airborne_state_common: airborne_state_common.clone(),
                attack_kind
            })
        } else {
            Err(AirAttackStateCreateError::AttackScriptNotFound { attack: attack_kind })
        }
    }

}


pub fn check_interrupt(state_context: &InterruptContext, airborne_state_common: &AirborneStateCommon) -> Option<FighterState> {
    if state_context
        .input
        .has_command(crate::input::FighterCommands::Attack)
    {
        let attack_kind = state_context
            .input
            .get_attack_command_type()
            .to_attack_kind_airborne(state_context.facing_direction);
        let state = AirAttackState::create(attack_kind, state_context.attack_script_assets, airborne_state_common);

        match state {
            Ok(state) => {
                Some(FighterState::AirAttack(state))
            },
            Err(create_error) => {
                error!("{}", create_error);
                None
            },
        }
    } else {
        None
    }
}