use crate::app_interface::{LearnedMove, MoveData, Pokemon};
use crate::handling::cached_value::CachedValue;
use crate::handling::temporary::Temporary;
use crate::{cached_value, ExternRef, ExternalReferenceType, Script};

struct ExecutingMoveInner {
    reference: ExternRef<ExecutingMove>,
    number_of_hits: CachedValue<u8>,
    user: CachedValue<Pokemon>,
    chosen_move: CachedValue<LearnedMove>,
    use_move: CachedValue<MoveData>,
}

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

impl ExecutingMove {
    pub(crate) fn new(reference: ExternRef<ExecutingMove>) -> Self {
        Self {
            inner: Temporary::new(
                reference.get_internal_index(),
                ExecutingMoveInner {
                    reference,
                    number_of_hits: cached_value!({ executing_move_get_number_of_hits(reference) }),
                    user: cached_value!({
                        executing_move_get_user(reference).get_value().unwrap()
                    }),
                    chosen_move: cached_value!({
                        executing_move_get_chosen_move(reference)
                            .get_value()
                            .unwrap()
                    }),
                    use_move: cached_value!({
                        executing_move_get_use_move(reference).get_value().unwrap()
                    }),
                },
            ),
        }
    }

    pub fn number_of_hits(&self) -> u8 {
        self.inner.value().number_of_hits.value()
    }
    pub fn user(&self) -> Pokemon {
        self.inner.value().user.value()
    }
    pub fn chosen_move(&self) -> LearnedMove {
        self.inner.value().chosen_move.value()
    }
    pub fn use_move(&self) -> MoveData {
        self.inner.value().use_move.value()
    }
    pub fn move_script(&self) -> Option<&dyn Script> {
        unsafe { executing_move_get_script(self.inner.value().reference).as_ref() }
    }
    pub fn number_of_targets(&self) -> usize {
        unsafe { executing_move_get_number_of_targets(self.inner.value().reference) }
    }
    pub fn is_pokemon_target(&self, pokemon: &Pokemon) -> bool {
        unsafe {
            executing_move_is_pokemon_target(self.inner.value().reference, pokemon.reference())
        }
    }
    pub fn get_hit_data(&self, pokemon: &Pokemon, hit: u8) -> HitData {
        unsafe {
            executing_move_get_hit_data(self.inner.value().reference, pokemon.reference(), hit)
                .get_value()
                .unwrap()
        }
    }
}

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

impl HitData {
    pub fn is_critical(&self) -> bool {
        unsafe { hit_data_is_critical(self.reference) }
    }
    pub fn base_power(&self) -> u8 {
        unsafe { hit_data_get_base_power(self.reference) }
    }
    pub fn effectiveness(&self) -> f32 {
        unsafe { hit_data_get_effectiveness(self.reference) }
    }
    pub fn damage(&self) -> u32 {
        unsafe { hit_data_get_damage(self.reference) }
    }
    pub fn move_type(&self) -> u8 {
        unsafe { hit_data_get_move_type(self.reference) }
    }
    pub fn has_failed(&self) -> bool {
        unsafe { hit_data_is_critical(self.reference) }
    }

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

impl ExternalReferenceType for ExecutingMove {
    fn from_extern_value(reference: ExternRef<Self>) -> Self {
        Self::new(reference)
    }
}

impl ExternalReferenceType for HitData {
    fn from_extern_value(reference: ExternRef<Self>) -> Self {
        Self { reference }
    }
}

extern "wasm" {
    fn executing_move_get_number_of_targets(r: ExternRef<ExecutingMove>) -> usize;
    fn executing_move_get_number_of_hits(r: ExternRef<ExecutingMove>) -> u8;
    fn executing_move_get_user(r: ExternRef<ExecutingMove>) -> ExternRef<Pokemon>;
    fn executing_move_get_chosen_move(r: ExternRef<ExecutingMove>) -> ExternRef<LearnedMove>;
    fn executing_move_get_use_move(r: ExternRef<ExecutingMove>) -> ExternRef<MoveData>;
    #[allow(improper_ctypes)]
    fn executing_move_get_script(r: ExternRef<ExecutingMove>) -> *const dyn Script;

    fn executing_move_is_pokemon_target(
        r: ExternRef<ExecutingMove>,
        pokemon: ExternRef<Pokemon>,
    ) -> bool;
    fn executing_move_get_hit_data(
        r: ExternRef<ExecutingMove>,
        target: ExternRef<Pokemon>,
        hit: u8,
    ) -> ExternRef<HitData>;

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

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