use crate::dynamic_data::event_hooks::event_hook::EventHook;
use crate::dynamic_data::flow::choice_queue::ChoiceQueue;
use crate::dynamic_data::history::history_holder::HistoryHolder;
use crate::dynamic_data::libraries::dynamic_library::DynamicLibrary;
use crate::dynamic_data::models::battle_party::BattleParty;
use crate::dynamic_data::models::battle_random::BattleRandom;
use crate::dynamic_data::models::battle_result::BattleResult;
use crate::dynamic_data::models::battle_side::BattleSide;
use crate::dynamic_data::script_handling::script::Script;
use crate::dynamic_data::script_handling::script_set::ScriptSet;
use crate::dynamic_data::script_handling::volatile_scripts::VolatileScripts;
use crate::{PkmnResult, ScriptCategory};
use std::sync::{Arc, RwLock};

#[derive(Debug)]
pub struct Battle<'a> {
    library: &'a DynamicLibrary<'a>,
    parties: Vec<BattleParty<'a>>,
    can_flee: bool,
    number_of_sides: u8,
    pokemon_per_side: u8,
    sides: Vec<BattleSide<'a>>,
    random: BattleRandom,
    choice_queue: ChoiceQueue,
    has_ended: bool,
    result: BattleResult,
    event_hook: EventHook,
    history_holder: Box<HistoryHolder>,
    current_turn: u32,
    volatile: Arc<RwLock<ScriptSet>>,
    last_turn_time: i64,
}

impl<'a> Battle<'a> {
    pub fn new(
        library: &'a DynamicLibrary<'a>,
        parties: Vec<BattleParty<'a>>,
        can_flee: bool,
        number_of_sides: u8,
        pokemon_per_side: u8,
        random_seed: Option<u128>,
    ) -> Arc<RwLock<Self>> {
        let random = if let Some(seed) = random_seed {
            BattleRandom::new_with_seed(seed)
        } else {
            BattleRandom::default()
        };
        let sides = Vec::with_capacity(number_of_sides as usize);
        let battle = Arc::new(RwLock::new(Self {
            library,
            parties,
            can_flee,
            number_of_sides,
            pokemon_per_side,
            sides,
            random,
            choice_queue: ChoiceQueue {},
            has_ended: false,
            result: BattleResult::Inconclusive,
            event_hook: Default::default(),
            history_holder: Box::new(HistoryHolder {}),
            current_turn: 0,
            volatile: Default::default(),
            last_turn_time: 0,
        }));

        for i in 0..number_of_sides {
            battle.write().unwrap().sides[i as usize] =
                BattleSide::new(i, Arc::downgrade(&battle), pokemon_per_side);
        }
        battle
    }

    pub fn library(&self) -> &'a DynamicLibrary<'a> {
        self.library
    }
    pub fn parties(&self) -> &Vec<BattleParty<'a>> {
        &self.parties
    }
    pub fn can_flee(&self) -> bool {
        self.can_flee
    }
    pub fn number_of_sides(&self) -> u8 {
        self.number_of_sides
    }
    pub fn pokemon_per_side(&self) -> u8 {
        self.pokemon_per_side
    }
    pub fn sides(&self) -> &Vec<BattleSide<'a>> {
        &self.sides
    }
    pub fn random(&self) -> &BattleRandom {
        &self.random
    }
    pub fn has_ended(&self) -> bool {
        self.has_ended
    }
    pub fn result(&self) -> BattleResult {
        self.result
    }
    pub fn event_hook(&self) -> &EventHook {
        &self.event_hook
    }
    pub fn history_holder(&self) -> &Box<HistoryHolder> {
        &self.history_holder
    }
    pub fn current_turn(&self) -> u32 {
        self.current_turn
    }
    pub fn last_turn_time(&self) -> i64 {
        self.last_turn_time
    }
    pub fn choice_queue(&self) -> &ChoiceQueue {
        &self.choice_queue
    }

    pub fn can_slot_be_filled(&self) -> bool {
        todo!()
    }
}

impl<'a> VolatileScripts<'a> for Battle<'a> {
    fn volatile_scripts(&self) -> &Arc<RwLock<ScriptSet>> {
        &self.volatile
    }

    fn load_volatile_script(&self, key: &str) -> PkmnResult<Box<dyn Script>> {
        self.library.load_script(ScriptCategory::Battle, key)
    }
}