use std::fmt::{Debug, Formatter};
use std::sync::{Arc, Mutex};

use crate::dynamic_data::models::executing_move::ExecutingMove;
use crate::dynamic_data::models::pokemon::Pokemon;
use crate::dynamic_data::script_handling::ScriptSource;
use crate::script_hook;
use crate::utils::Random;

#[derive(Default)]
pub struct BattleRandom {
    random: Mutex<Random>,
}

impl BattleRandom {
    pub fn new_with_seed(seed: u128) -> Self {
        BattleRandom {
            random: Mutex::new(Random::new(seed)),
        }
    }

    pub fn get_rng(&self) -> &Mutex<Random> {
        &self.random
    }

    pub fn get(&self) -> i32 {
        return self.get_rng().lock().unwrap().get();
    }
    pub fn get_max(&self, max: i32) -> i32 {
        return self.get_rng().lock().unwrap().get_max(max);
    }
    pub fn get_between(&self, min: i32, max: i32) -> i32 {
        return self.get_rng().lock().unwrap().get_between(min, max);
    }

    pub fn effect_chance(
        &self,
        mut chance: f32,
        executing_move: &ExecutingMove,
        target: &Arc<Pokemon>,
        hit_number: u8,
    ) -> bool {
        script_hook!(
            change_effect_chance,
            executing_move,
            executing_move,
            target,
            hit_number,
            &mut chance
        );
        script_hook!(
            change_incoming_effect_chance,
            target,
            executing_move,
            target,
            hit_number,
            &mut chance
        );
        self.get_rng().lock().unwrap().get_float() < (chance / 100.0)
    }
}

impl Debug for BattleRandom {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("BattleRandom").finish()
    }
}

impl Clone for BattleRandom {
    fn clone(&self) -> Self {
        Self {
            random: Mutex::new(self.random.lock().unwrap().clone()),
        }
    }
}