use crate::defines::{LevelInt, MAX_MOVES};
use crate::dynamic_data::event_hooks::event_hook::Event;
use crate::dynamic_data::libraries::dynamic_library::DynamicLibrary;
use crate::dynamic_data::models::battle::Battle;
use crate::dynamic_data::models::damage_source::DamageSource;
use crate::dynamic_data::models::learned_move::{LearnedMove, MoveLearnMethod};
use crate::dynamic_data::script_handling::script::{Script, ScriptContainer};
use crate::dynamic_data::script_handling::script_set::ScriptSet;
use crate::dynamic_data::script_handling::volatile_scripts::VolatileScripts;
use crate::dynamic_data::script_handling::{ScriptSource, ScriptSourceData, ScriptWrapper};
use crate::static_data::items::item::Item;
use crate::static_data::natures::Nature;
use crate::static_data::species_data::ability::Ability;
use crate::static_data::species_data::ability_index::AbilityIndex;
use crate::static_data::species_data::form::Form;
use crate::static_data::species_data::gender::Gender;
use crate::static_data::species_data::species::Species;
use crate::static_data::statistic_set::{ClampedStatisticSet, StatisticSet};
use crate::static_data::DataLibrary;
use crate::utils::random::Random;
use crate::{script_hook, PkmnResult, ScriptCategory, StringKey};
use atomic::Atomic;
use parking_lot::RwLock;
use std::ops::{Deref, DerefMut};
use std::sync::atomic::{AtomicBool, AtomicI8, AtomicU32, AtomicU8, Ordering};
use std::sync::{Arc, Weak};

#[derive(Debug)]
pub struct PokemonBattleData<'pokemon, 'library> {
    battle: *mut Battle<'pokemon, 'library>,
    battle_side_index: AtomicU8,
    index: AtomicU8,
    on_battle_field: AtomicBool,
    seen_opponents: RwLock<Vec<Weak<Pokemon<'pokemon, 'library>>>>,
}

impl<'pokemon, 'library> PokemonBattleData<'pokemon, 'library> {
    pub fn battle_mut(&mut self) -> Option<&mut Battle<'pokemon, 'library>> {
        unsafe { self.battle.as_mut() }
    }
    pub fn battle(&self) -> Option<&Battle<'pokemon, 'library>> {
        unsafe { self.battle.as_ref() }
    }

    pub fn battle_side_index(&self) -> u8 {
        self.battle_side_index.load(Ordering::Relaxed)
    }
    pub fn index(&self) -> u8 {
        self.index.load(Ordering::Relaxed)
    }
    pub fn on_battle_field(&self) -> bool {
        self.on_battle_field.load(Ordering::Relaxed)
    }
    pub fn seen_opponents(&self) -> &RwLock<Vec<Weak<Pokemon<'pokemon, 'library>>>> {
        &self.seen_opponents
    }
}

#[derive(Debug)]
pub struct Pokemon<'own, 'library>
where
    'own: 'library,
{
    library: &'own DynamicLibrary,
    species: &'own Species,
    form: &'own Form,

    display_species: Option<&'own Species>,
    display_form: Option<&'own Form>,

    level: LevelInt,
    experience: AtomicU32,
    unique_identifier: u32,
    gender: Gender,
    coloring: u8,
    held_item: Option<&'own Item>,
    current_health: AtomicU32,

    weight: Atomic<f32>,
    height: Atomic<f32>,

    stat_boost: ClampedStatisticSet<AtomicI8, -6, 6>,
    flat_stats: StatisticSet<AtomicU32>,
    boosted_stats: StatisticSet<AtomicU32>,
    individual_values: ClampedStatisticSet<AtomicU8, 0, 31>,
    effort_values: ClampedStatisticSet<AtomicU8, 0, 252>,
    nature: &'own Nature,

    nickname: Option<String>,

    ability_index: AbilityIndex,
    is_ability_overridden: bool,
    override_ability: Option<Ability>,

    battle_data: RwLock<Option<PokemonBattleData<'own, 'library>>>,

    moves: RwLock<[Option<Arc<LearnedMove<'library>>>; MAX_MOVES]>,
    allowed_experience: bool,

    types: Vec<u8>,
    is_egg: bool,
    is_caught: bool,

    held_item_trigger_script: ScriptContainer,
    ability_script: ScriptContainer,
    status_script: ScriptContainer,
    volatile: Arc<RwLock<ScriptSet>>,

    script_source_data: RwLock<ScriptSourceData>,
}

impl<'own, 'library> Pokemon<'own, 'library> {
    pub fn new(
        library: &'own DynamicLibrary,
        species: &'own Species,
        form: &'own Form,
        ability: AbilityIndex,
        level: LevelInt,
        unique_identifier: u32,
        gender: Gender,
        coloring: u8,
        nature: &StringKey,
    ) -> Self {
        // Calculate experience from the level for the specified growth rate.
        let experience = library
            .static_data()
            .growth_rates()
            .calculate_experience(species.growth_rate(), level);
        let weight = form.weight();
        let height = form.height();
        let nature = library
            .static_data()
            .natures()
            .get_nature(nature)
            .unwrap_or_else(|| panic!("Unknown nature name was given: {}.", &nature));
        let mut pokemon = Self {
            library,
            species,
            form,
            display_species: None,
            display_form: None,
            level,
            experience: AtomicU32::new(experience),
            unique_identifier,
            gender,
            coloring,
            held_item: None,
            current_health: AtomicU32::new(1),
            weight: Atomic::new(weight),
            height: Atomic::new(height),
            stat_boost: Default::default(),
            flat_stats: Default::default(),
            boosted_stats: Default::default(),
            individual_values: Default::default(),
            effort_values: Default::default(),
            nature,
            nickname: None,
            ability_index: ability,
            is_ability_overridden: false,
            override_ability: None,
            battle_data: RwLock::new(None),
            moves: RwLock::new([None, None, None, None]),
            allowed_experience: false,
            types: form.types().to_vec(),
            is_egg: false,
            is_caught: false,
            held_item_trigger_script: ScriptContainer::default(),
            ability_script: ScriptContainer::default(),
            status_script: ScriptContainer::default(),
            volatile: Default::default(),
            script_source_data: Default::default(),
        };
        pokemon.recalculate_flat_stats();
        let health = pokemon.flat_stats().hp();
        pokemon.current_health = AtomicU32::new(health);

        pokemon
    }

    pub fn library(&self) -> &'own DynamicLibrary {
        self.library
    }
    pub fn species(&self) -> &'own Species {
        self.species
    }
    pub fn form(&self) -> &'own Form {
        self.form
    }
    pub fn display_species(&self) -> &'own Species {
        if let Some(v) = self.display_species {
            v
        } else {
            self.species
        }
    }
    pub fn display_form(&self) -> &'own Form {
        if let Some(v) = self.display_form {
            v
        } else {
            self.form
        }
    }

    pub fn level(&self) -> LevelInt {
        self.level
    }
    pub fn experience(&self) -> u32 {
        self.experience.load(Ordering::Relaxed)
    }
    pub fn unique_identifier(&self) -> u32 {
        self.unique_identifier
    }
    pub fn gender(&self) -> Gender {
        self.gender
    }
    pub fn coloring(&self) -> u8 {
        self.coloring
    }
    pub fn held_item(&self) -> Option<&'own Item> {
        self.held_item
    }
    pub fn has_held_item(&self, name: &StringKey) -> bool {
        // Only true if we have an item, and the item name is the same as the requested item.
        if let Some(v) = self.held_item {
            return v.name() == name;
        }
        false
    }
    pub fn set_held_item(&mut self, item: &'own Item) {
        self.held_item = Some(item);
    }
    pub fn remove_held_item(&mut self) {
        self.held_item = None;
    }
    pub fn consume_held_item(&mut self) -> bool {
        if self.held_item.is_none() {
            return false;
        }
        let script = self.library.load_item_script(self.held_item.unwrap()).unwrap();
        if script.is_none() {
            return false;
        }

        // TODO: the entire item use part.
        todo!();
    }

    pub fn current_health(&self) -> u32 {
        self.current_health.load(Ordering::Relaxed)
    }
    pub fn max_health(&self) -> u32 {
        self.boosted_stats.hp()
    }
    pub fn weight(&self) -> f32 {
        self.weight.load(Ordering::Relaxed)
    }
    pub fn height(&self) -> f32 {
        self.height.load(Ordering::Relaxed)
    }
    pub fn nickname(&self) -> &Option<String> {
        &self.nickname
    }
    pub fn real_ability(&self) -> &AbilityIndex {
        &self.ability_index
    }
    pub fn types(&self) -> &Vec<u8> {
        &self.types
    }
    pub fn learned_moves(&self) -> &RwLock<[Option<Arc<LearnedMove<'library>>>; MAX_MOVES]> {
        &self.moves
    }
    pub fn status(&self) -> &ScriptContainer {
        &self.status_script
    }
    pub fn flat_stats(&self) -> &StatisticSet<AtomicU32> {
        &self.flat_stats
    }
    pub fn boosted_stats(&self) -> &StatisticSet<AtomicU32> {
        &self.boosted_stats
    }
    pub fn stat_boost(&self) -> &ClampedStatisticSet<AtomicI8, -6, 6> {
        &self.stat_boost
    }
    pub fn individual_values(&self) -> &ClampedStatisticSet<AtomicU8, 0, 31> {
        &self.individual_values
    }
    pub fn effort_values(&self) -> &ClampedStatisticSet<AtomicU8, 0, 252> {
        &self.effort_values
    }

    pub fn get_battle(&self) -> Option<&Battle<'own, 'library>> {
        let r = self.battle_data.read();
        if let Some(data) = &r.deref() {
            unsafe { data.battle.as_ref() }
        } else {
            None
        }
    }
    pub fn get_battle_side_index(&self) -> Option<u8> {
        self.battle_data.read().as_ref().map(|data| data.battle_side_index())
    }
    pub fn get_battle_index(&self) -> Option<u8> {
        self.battle_data.read().as_ref().map(|data| data.index())
    }
    pub fn is_ability_overriden(&self) -> bool {
        self.is_ability_overridden
    }
    pub fn active_ability(&self) -> &Ability {
        if self.is_ability_overridden {
            if let Some(v) = &self.override_ability {
                return v;
            }
        }
        self.library
            .static_data()
            .abilities()
            .get(self.form.get_ability(self.ability_index))
            .unwrap()
    }

    pub fn ability_script(&self) -> &ScriptContainer {
        &self.ability_script
    }

    // pub fn seen_opponents(&self) -> &RwLock<Option<PokemonBattleData<'own, 'library>>> {
    //     &self.battle_data.read
    // }
    pub fn allowed_experience_gain(&self) -> bool {
        self.allowed_experience
    }

    pub fn nature(&self) -> &'own Nature {
        self.nature
    }

    pub fn recalculate_flat_stats(&self) {
        self.library
            .stat_calculator()
            .calculate_flat_stats(self, &self.flat_stats);
        self.recalculate_boosted_stats();
    }
    pub fn recalculate_boosted_stats(&self) {
        self.library
            .stat_calculator()
            .calculate_boosted_stats(self, &self.boosted_stats);
    }

    pub fn change_species(&mut self, species: &'own Species, form: &'own Form) {
        self.species = species;
        self.form = form;

        // If the pokemon is genderless, but it's new species is not, we want to set its gender
        if self.gender != Gender::Genderless && species.gender_rate() < 0.0 {
            // If we're in battle, use the battle random for predictability
            let r = self.battle_data.read();
            if let Some(data) = r.deref() {
                let mut random = data.battle().unwrap().random().get_rng().lock().unwrap();
                self.gender = species.get_random_gender(random.deref_mut());
            } else {
                // If we're not in battle, just use a new random.
                self.gender = species.get_random_gender(&mut Random::default());
            }
        }
        // Else if the new species is genderless, but the pokemon has a gender, make the creature genderless.
        else if species.gender_rate() < 0.0 && self.gender != Gender::Genderless {
            self.gender = Gender::Genderless;
        }
        let r = self.battle_data.read();
        if let Some(battle_data) = &r.deref() {
            if let Some(battle) = battle_data.battle() {
                battle.event_hook().trigger(Event::SpeciesChange {
                    pokemon: self,
                    species,
                    form,
                })
            }
        }
    }

    pub fn change_form(&mut self, form: &'own Form) {
        if std::ptr::eq(self.form, form) {
            return;
        }
        self.form = form;

        self.types.clear();
        for t in form.types() {
            self.types.push(*t);
        }
        self.weight.store(form.weight(), Ordering::SeqCst);
        self.height.store(form.height(), Ordering::SeqCst);

        let ability_script = self
            .library
            .load_script(ScriptCategory::Ability, self.active_ability().name())
            .unwrap();
        if let Some(ability_script) = ability_script {
            self.ability_script.set(ability_script);
            // Ensure the ability script gets initialized with the parameters for the ability.
            self.ability_script()
                .get()
                .as_mut()
                .unwrap()
                .as_mut()
                .on_initialize(self.active_ability().parameters())
        } else {
            self.ability_script.clear();
        }
        let old_health = self.max_health();
        self.recalculate_flat_stats();
        let diff_health = (self.max_health() - old_health) as i32;
        if self.current_health() == 0 && (self.current_health() as i32) < -diff_health {
            self.current_health.store(0, Ordering::SeqCst);
        } else {
            self.current_health.fetch_add(diff_health as u32, Ordering::Acquire);
        }
        // TODO: consider form specific attacks?

        let r = self.battle_data.read();
        if let Some(battle_data) = r.deref() {
            if let Some(battle) = battle_data.battle() {
                battle.event_hook().trigger(Event::FormChange { pokemon: self, form })
            }
        }
    }

    pub fn is_usable(&self) -> bool {
        !self.is_caught && !self.is_egg && !self.is_fainted()
    }

    pub fn is_fainted(&self) -> bool {
        self.current_health() == 0
    }

    pub fn set_battle_data(&self, battle: *mut Battle<'own, 'library>, battle_side_index: u8) {
        let mut w = self.battle_data.write();
        if let Some(battle_data) = w.deref_mut() {
            battle_data.battle = battle;
            battle_data.battle_side_index.store(battle_side_index, Ordering::SeqCst);
        } else {
            w.replace(PokemonBattleData {
                battle,
                battle_side_index: AtomicU8::new(battle_side_index),
                index: AtomicU8::new(0),
                on_battle_field: AtomicBool::new(false),
                seen_opponents: Default::default(),
            });
        }
    }

    pub fn set_on_battlefield(&self, value: bool) {
        let r = self.battle_data.read();
        if let Some(data) = &mut r.deref() {
            data.on_battle_field.store(value, Ordering::SeqCst);
            if !value {
                self.volatile.write().clear();
                self.weight.store(self.form.weight(), Ordering::SeqCst);
                self.height.store(self.form.height(), Ordering::SeqCst);
            }
        }
    }

    pub fn set_battle_index(&self, index: u8) {
        let r = self.battle_data.read();
        if let Some(data) = r.deref() {
            data.index.store(index, Ordering::SeqCst)
        }
    }

    pub fn is_on_battlefield(&self) -> bool {
        self.battle_data.read().is_some_and(|a| a.on_battle_field())
    }

    pub fn mark_opponent_as_seen(&self, pokemon: Weak<Pokemon<'own, 'library>>) {
        let r = self.battle_data.read();
        if let Some(battle_data) = &r.deref() {
            let mut opponents = battle_data.seen_opponents().write();
            for seen_opponent in opponents.deref() {
                if seen_opponent.ptr_eq(&pokemon) {
                    return;
                }
            }
            opponents.push(pokemon);
        }
    }

    pub fn damage(&self, mut damage: u32, source: DamageSource) {
        if damage > self.current_health() {
            damage = self.current_health();
        }
        if damage == 0 {
            return;
        }
        let new_health = self.current_health() - damage;
        if let Some(battle_data) = &self.battle_data.read().deref() {
            if let Some(battle) = battle_data.battle() {
                battle.event_hook().trigger(Event::Damage {
                    pokemon: self,
                    source,
                    original_health: self.current_health(),
                    new_health,
                });
                // TODO: register history
            }
        }
        if self.battle_data.read().is_some_and(|a| a.on_battle_field()) {
            script_hook!(on_damage, self, self, source, self.current_health(), new_health);
        }

        self.current_health.store(new_health, Ordering::SeqCst);
        if self.is_fainted() && damage > 0 {
            self.on_faint(source);
        }
    }

    pub fn on_faint(&self, source: DamageSource) {
        let r = self.battle_data.read();
        if let Some(battle_data) = r.deref() {
            if let Some(battle) = battle_data.battle() {
                battle.event_hook().trigger(Event::Faint { pokemon: self });
                script_hook!(on_faint, self, self, source);
                script_hook!(on_remove, self,);

                if !battle.can_slot_be_filled(battle_data.battle_side_index(), battle_data.index()) {
                    battle.sides()[battle_data.battle_side_index() as usize]
                        .mark_slot_as_unfillable(battle_data.index());
                }

                battle.validate_battle_state();
            }
        }
    }

    pub fn learn_move(&self, move_name: &StringKey, learn_method: MoveLearnMethod) {
        let mut learned_moves = self.learned_moves().write();
        let move_pos = learned_moves.iter().position(|a| a.is_none());
        if move_pos.is_none() {
            panic!("No more moves with an empty space found.");
        }
        let move_data = self.library.static_data().moves().get(move_name).unwrap();
        learned_moves[move_pos.unwrap()] = Some(Arc::new(LearnedMove::new(move_data, learn_method)));
    }
}

impl<'own, 'library> ScriptSource<'own> for Pokemon<'own, 'library> {
    fn get_script_count(&self) -> usize {
        let mut c = 3;
        if let Some(battle_data) = &self.battle_data.read().deref() {
            if let Some(battle) = battle_data.battle() {
                c += battle.sides()[battle_data.battle_side_index() as usize].get_script_count();
            }
        }
        c
    }

    fn get_script_source_data(&self) -> &RwLock<ScriptSourceData> {
        &self.script_source_data
    }

    fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
        scripts.push((&self.held_item_trigger_script).into());
        scripts.push((&self.ability_script).into());
        scripts.push((&self.status_script).into());
        scripts.push((&self.volatile).into());
    }

    fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
        self.get_own_scripts(scripts);
        if let Some(battle_data) = &self.battle_data.read().deref() {
            if let Some(battle) = battle_data.battle() {
                battle.sides()[battle_data.battle_side_index() as usize].collect_scripts(scripts);
            }
        }
    }
}

impl<'own, 'library> VolatileScripts<'own> for Pokemon<'own, 'library> {
    fn volatile_scripts(&self) -> &Arc<RwLock<ScriptSet>> {
        &self.volatile
    }

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

#[cfg(test)]
pub mod test {
    use crate::dynamic_data::libraries::dynamic_library;
    use crate::dynamic_data::models::pokemon::Pokemon;
    use crate::static_data::libraries::data_library::DataLibrary;
    use crate::static_data::species_data::ability_index::AbilityIndex;
    use crate::static_data::species_data::gender::Gender;

    #[test]
    fn construct_pokemon() {
        let lib = dynamic_library::test::build();
        let species = lib.static_data().species().get(&"foo".into()).unwrap();
        let form = species.get_form(&"default".into()).unwrap();

        let pokemon = Pokemon::new(
            &lib,
            species,
            form,
            AbilityIndex {
                hidden: false,
                index: 0,
            },
            10,
            0,
            Gender::Male,
            0,
            &"test_nature".into(),
        );
        assert_eq!(pokemon.species.name(), &"foo".into());
        assert_eq!(pokemon.form.name(), &"default".into());
    }
}