Gen7ScriptsRs/pkmn_lib_interface/src/app_interface/dynamic_data/executing_move.rs

use crate::app_interface::{LearnedMove, MoveData, Pokemon};
use crate::handling::Script;
use alloc::boxed::Box;
use alloc::rc::Rc;

#[cfg_attr(feature = "mock_data", mockall::automock)]
pub trait ExecutingMoveTrait {
    fn number_of_hits(&self) -> u8;
    fn user(&self) -> Pokemon;
    fn chosen_move(&self) -> LearnedMove;
    fn use_move(&self) -> MoveData;
    fn move_script<'a>(&'a self) -> PkmnResult<Option<&'a Box<dyn Script>>>;
    fn number_of_targets(&self) -> PkmnResult<usize>;
    fn is_pokemon_target(&self, pokemon: &Pokemon) -> PkmnResult<bool>;
    fn get_hit_data(&self, pokemon: &Pokemon, hit: u8) -> PkmnResult<HitData>;
}

#[cfg_attr(feature = "mock_data", mockall::automock)]
pub trait HitDataTrait {
    fn is_critical(&self) -> PkmnResult<bool>;
    fn base_power(&self) -> PkmnResult<u8>;
    fn effectiveness(&self) -> PkmnResult<f32>;
    fn damage(&self) -> PkmnResult<u32>;
    fn move_type(&self) -> PkmnResult<u8>;
    fn has_failed(&self) -> PkmnResult<bool>;
    fn set_critical(&self, critical: bool) -> PkmnResult<()>;
    fn set_effectiveness(&self, effectiveness: f32) -> PkmnResult<()>;
    fn set_damage(&self, damage: u32) -> PkmnResult<()>;
    fn set_move_type(&self, move_type: u8) -> PkmnResult<()>;
    fn fail(&self) -> PkmnResult<()>;
}

pub type ExecutingMove = Rc<dyn ExecutingMoveTrait>;
#[cfg(feature = "mock_data")]
pub type MockExecutingMove = MockExecutingMoveTrait;

pub type HitData = Rc<dyn HitDataTrait>;
#[cfg(feature = "mock_data")]
pub type MockHitData = MockHitDataTrait;

use crate::PkmnResult;
#[cfg(not(feature = "mock_data"))]
pub use implementation::*;

#[cfg(not(feature = "mock_data"))]
mod implementation {
    use super::*;
    use crate::app_interface::{LearnedMoveImpl, MoveDataImpl, PokemonImpl};
    use crate::handling::cached_value::CachedValue;
    use crate::handling::extern_ref::{ExternRef, ExternalReferenceType};
    use crate::handling::temporary::Temporary;
    use crate::handling::wasm_result::WasmResult;
    use crate::{cached_value, PkmnResult};
    use alloc::boxed::Box;

    #[derive(Clone)]
    pub struct ExecutingMoveImpl {
        inner: Temporary<ExecutingMoveInner>,
    }

    struct ExecutingMoveInner {
        reference: ExternRef<ExecutingMoveImpl>,
        number_of_hits: CachedValue<u8>,
        user: CachedValue<Pokemon>,
        chosen_move: CachedValue<Rc<LearnedMoveImpl>>,
        use_move: CachedValue<MoveData>,
    }

    impl ExecutingMoveImpl {
        #[cfg(not(feature = "mock_data"))]
        pub(crate) fn new(reference: ExternRef<Self>) -> Self {
            Self {
                inner: Temporary::new(
                    reference.get_internal_index(),
                    ExecutingMoveInner {
                        reference,
                        number_of_hits: cached_value!({
                            executing_move_get_number_of_hits(reference).unwrap()
                        }),
                        user: cached_value!({
                            Rc::new(
                                executing_move_get_user(reference)
                                    .unwrap()
                                    .get_value()
                                    .unwrap(),
                            )
                        }),
                        chosen_move: cached_value!({
                            Rc::new(
                                executing_move_get_chosen_move(reference)
                                    .unwrap()
                                    .get_value()
                                    .unwrap(),
                            )
                        }),
                        use_move: cached_value!({
                            Rc::new(
                                executing_move_get_use_move(reference)
                                    .unwrap()
                                    .get_value()
                                    .unwrap(),
                            )
                        }),
                    },
                ),
            }
        }
    }

    #[cfg(not(feature = "mock_data"))]
    impl ExecutingMoveTrait for ExecutingMoveImpl {
        fn number_of_hits(&self) -> u8 {
            self.inner.value().number_of_hits.value()
        }
        fn user(&self) -> Pokemon {
            self.inner.value().user.value()
        }
        fn chosen_move(&self) -> LearnedMove {
            self.inner.value().chosen_move.value()
        }
        fn use_move(&self) -> MoveData {
            self.inner.value().use_move.value()
        }
        fn move_script(&self) -> PkmnResult<Option<&Box<dyn Script>>> {
            unsafe {
                Ok(
                    (executing_move_get_script(self.inner.value().reference).as_res()?
                        as *const Box<dyn Script>)
                        .as_ref(),
                )
            }
        }
        fn number_of_targets(&self) -> PkmnResult<usize> {
            unsafe { executing_move_get_number_of_targets(self.inner.value().reference).as_res() }
        }
        fn is_pokemon_target(&self, pokemon: &Pokemon) -> PkmnResult<bool> {
            unsafe {
                executing_move_is_pokemon_target(
                    self.inner.value().reference,
                    pokemon.reference().into(),
                )
                .as_res()
            }
        }
        fn get_hit_data(&self, pokemon: &Pokemon, hit: u8) -> PkmnResult<HitData> {
            unsafe {
                Ok(Rc::new(
                    executing_move_get_hit_data(
                        self.inner.value().reference,
                        pokemon.reference().into(),
                        hit,
                    )
                    .as_res()?
                    .get_value()
                    .unwrap(),
                ))
            }
        }
    }

    #[derive(Clone)]
    pub struct HitDataImpl {
        reference: ExternRef<HitDataImpl>,
    }

    #[cfg(not(feature = "mock_data"))]
    impl HitDataTrait for HitDataImpl {
        fn is_critical(&self) -> PkmnResult<bool> {
            unsafe { hit_data_is_critical(self.reference).as_res() }
        }
        fn base_power(&self) -> PkmnResult<u8> {
            unsafe { hit_data_get_base_power(self.reference).as_res() }
        }
        fn effectiveness(&self) -> PkmnResult<f32> {
            unsafe { hit_data_get_effectiveness(self.reference).as_res() }
        }
        fn damage(&self) -> PkmnResult<u32> {
            unsafe { hit_data_get_damage(self.reference).as_res() }
        }
        fn move_type(&self) -> PkmnResult<u8> {
            unsafe { hit_data_get_move_type(self.reference).as_res() }
        }
        fn has_failed(&self) -> PkmnResult<bool> {
            unsafe { hit_data_is_critical(self.reference).as_res() }
        }

        fn set_critical(&self, critical: bool) -> PkmnResult<()> {
            unsafe { hit_data_set_critical(self.reference, critical).as_res() }
        }
        fn set_effectiveness(&self, effectiveness: f32) -> PkmnResult<()> {
            unsafe { hit_data_set_effectiveness(self.reference, effectiveness).as_res() }
        }
        fn set_damage(&self, damage: u32) -> PkmnResult<()> {
            unsafe { hit_data_set_damage(self.reference, damage).as_res() }
        }
        fn set_move_type(&self, move_type: u8) -> PkmnResult<()> {
            unsafe { hit_data_set_move_type(self.reference, move_type).as_res() }
        }
        fn fail(&self) -> PkmnResult<()> {
            unsafe { hit_data_fail(self.reference).as_res() }
        }
    }

    #[cfg(not(feature = "mock_data"))]
    impl ExternalReferenceType for ExecutingMoveImpl {
        fn from_extern_value(reference: ExternRef<Self>) -> Self {
            Self::new(reference)
        }
    }

    #[cfg(not(feature = "mock_data"))]
    impl ExternalReferenceType for HitDataImpl {
        fn from_extern_value(reference: ExternRef<Self>) -> Self {
            Self { reference }
        }
    }

    #[cfg(not(feature = "mock_data"))]
    extern "wasm" {
        fn executing_move_get_number_of_targets(
            r: ExternRef<ExecutingMoveImpl>,
        ) -> WasmResult<usize>;
        fn executing_move_get_number_of_hits(r: ExternRef<ExecutingMoveImpl>) -> WasmResult<u8>;
        fn executing_move_get_user(
            r: ExternRef<ExecutingMoveImpl>,
        ) -> WasmResult<ExternRef<PokemonImpl>>;
        fn executing_move_get_chosen_move(
            r: ExternRef<ExecutingMoveImpl>,
        ) -> WasmResult<ExternRef<LearnedMoveImpl>>;
        fn executing_move_get_use_move(
            r: ExternRef<ExecutingMoveImpl>,
        ) -> WasmResult<ExternRef<MoveDataImpl>>;
        #[allow(improper_ctypes)]
        fn executing_move_get_script(r: ExternRef<ExecutingMoveImpl>) -> WasmResult<u32>;

        fn executing_move_is_pokemon_target(
            r: ExternRef<ExecutingMoveImpl>,
            pokemon: ExternRef<PokemonImpl>,
        ) -> WasmResult<bool>;
        fn executing_move_get_hit_data(
            r: ExternRef<ExecutingMoveImpl>,
            target: ExternRef<PokemonImpl>,
            hit: u8,
        ) -> WasmResult<ExternRef<HitDataImpl>>;

        fn hit_data_is_critical(r: ExternRef<HitDataImpl>) -> WasmResult<bool>;
        fn hit_data_get_base_power(r: ExternRef<HitDataImpl>) -> WasmResult<u8>;
        fn hit_data_get_effectiveness(r: ExternRef<HitDataImpl>) -> WasmResult<f32>;
        fn hit_data_get_damage(r: ExternRef<HitDataImpl>) -> WasmResult<u32>;
        fn hit_data_get_move_type(r: ExternRef<HitDataImpl>) -> WasmResult<u8>;
        fn hit_data_has_failed(r: ExternRef<HitDataImpl>) -> WasmResult<bool>;

        fn hit_data_set_critical(r: ExternRef<HitDataImpl>, critical: bool) -> WasmResult<()>;
        fn hit_data_set_base_power(r: ExternRef<HitDataImpl>, power: u8) -> WasmResult<()>;
        fn hit_data_set_effectiveness(
            r: ExternRef<HitDataImpl>,
            effectiveness: f32,
        ) -> WasmResult<()>;
        fn hit_data_set_damage(r: ExternRef<HitDataImpl>, damage: u32) -> WasmResult<()>;
        fn hit_data_set_move_type(r: ExternRef<HitDataImpl>, move_type: u8) -> WasmResult<()>;
        fn hit_data_fail(r: ExternRef<HitDataImpl>) -> WasmResult<()>;
    }
}