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::utils::Random;
use crate::{script_hook, ValueIdentifiable, ValueIdentifier};

/// The RNG for a battle.
#[derive(Default)]
pub struct BattleRandom {
    /// A unique identifier so we know what value this is.
    identifier: ValueIdentifier,
    /// The actual underlying RNG. This is in a mutex, so it is thread safe, and can be ran
    /// predictably, with guaranteed the same outputs.
    random: Mutex<Random>,
}

impl BattleRandom {
    /// Initializes a new RNG with a given seed.
    pub fn new_with_seed(seed: u128) -> Self {
        BattleRandom {
            identifier: Default::default(),
            random: Mutex::new(Random::new(seed)),
        }
    }

    /// Returns the underlying random number generator.
    pub fn get_rng(&self) -> &Mutex<Random> {
        &self.random
    }

    /// Get a random 32 bit integer. Can be any value between min int and max int.
    pub fn get(&self) -> i32 {
        return self.get_rng().lock().unwrap().get();
    }
    /// Get a random 32 bit integer between 0 and max.
    pub fn get_max(&self, max: i32) -> i32 {
        return self.get_rng().lock().unwrap().get_max(max);
    }
    /// Get a random 32 bit integer between min and max.
    pub fn get_between(&self, min: i32, max: i32) -> i32 {
        return self.get_rng().lock().unwrap().get_between(min, max);
    }

    /// Gets whether or not a move triggers its secondary effect. This takes its chance, and
    /// rolls whether it triggers. As a side effect this run scripts to allow modifying this random
    /// chance.
    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
        );
        if chance < 100.0 {
            if chance > 0.0 {
                self.get_rng().lock().unwrap().get_float() < (chance / 100.0)
            } else {
                false
            }
        } else {
            true
        }
    }
}

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 {
            identifier: Default::default(),
            random: Mutex::new(self.random.lock().unwrap().clone()),
        }
    }
}

impl ValueIdentifiable for BattleRandom {
    fn value_identifier(&self) -> ValueIdentifier {
        self.identifier
    }
}