use crate::app_interface::{BattleParty, BattleRandom, BattleSide, ChoiceQueue, Pokemon};
use crate::handling::cached_value::CachedValue;
use crate::handling::Cacheable;
use crate::{
    cached_value, cached_value_getters, wasm_value_getters, DynamicLibrary, ExternRef,
    ExternalReferenceType, ImmutableList, VecExternRef,
};
use alloc::rc::Rc;

struct BattleInner {
    reference: ExternRef<Battle>,
    library: CachedValue<DynamicLibrary>,
    parties: CachedValue<ImmutableList<BattleParty>>,
    sides: CachedValue<ImmutableList<BattleSide>>,
    random: CachedValue<BattleRandom>,
    choice_queue: CachedValue<ChoiceQueue>,
}

#[derive(Clone)]
pub struct Battle {
    inner: Rc<BattleInner>,
}

impl Battle {
    #[cfg(not(feature = "mock_data"))]
    pub fn new(reference: ExternRef<Battle>) -> Self {
        Self::from_ref(reference, &|reference| Self {
            inner: Rc::new(BattleInner {
                reference,
                library: cached_value!({ battle_get_library(reference).get_value().unwrap() }),
                parties: cached_value!({ battle_get_parties(reference).get_immutable_list() }),
                sides: cached_value!({ battle_get_sides(reference).get_immutable_list() }),
                random: cached_value!({ battle_get_random(reference).get_value().unwrap() }),
                choice_queue: cached_value!({
                    battle_get_choice_queue(reference).get_value().unwrap()
                }),
            }),
        })
    }

    cached_value_getters! {
        pub fn library(&self) -> DynamicLibrary;
        pub fn parties(&self) -> ImmutableList<BattleParty>;
        pub fn sides(&self) -> ImmutableList<BattleSide>;
        pub fn random(&self) -> BattleRandom;
        pub fn choice_queue(&self) -> ChoiceQueue;
    }

    #[cfg(not(feature = "mock_data"))]
    pub fn get_pokemon(&self, side: u8, index: u8) -> Option<Pokemon> {
        unsafe { battle_get_pokemon(self.inner.reference, side, index).get_value() }
    }

    pub fn find_party_for_pokemon(&self, pokemon: &Pokemon) -> Option<BattleParty> {
        unsafe {
            battle_find_party_for_pokemon(self.inner.reference, pokemon.reference()).get_value()
        }
    }
}

wasm_value_getters! {
    Battle,
    pub fn can_flee(&self) -> bool;
    pub fn number_of_sides(&self) -> u8;
    pub fn pokemon_per_side(&self) -> u8;
    pub fn has_ended(&self) -> bool;
    pub fn has_ended_conclusively(&self) -> bool;
    pub fn winning_side(&self) -> u8;
    pub fn current_turn(&self) -> u32;
}

crate::handling::cacheable::cacheable!(Battle);

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

#[cfg(not(feature = "mock_data"))]
extern "wasm" {
    fn battle_get_library(r: ExternRef<Battle>) -> ExternRef<DynamicLibrary>;
    fn battle_get_parties(r: ExternRef<Battle>) -> VecExternRef<BattleParty>;
    fn battle_get_sides(r: ExternRef<Battle>) -> VecExternRef<BattleSide>;
    fn battle_get_random(r: ExternRef<Battle>) -> ExternRef<BattleRandom>;
    fn battle_get_choice_queue(r: ExternRef<Battle>) -> ExternRef<ChoiceQueue>;
    fn battle_get_pokemon(r: ExternRef<Battle>, side: u8, index: u8) -> ExternRef<Pokemon>;
    fn battle_find_party_for_pokemon(
        r: ExternRef<Battle>,
        mon: ExternRef<Pokemon>,
    ) -> ExternRef<BattleParty>;
}