PkmnLib_rs/src/dynamic_data/script_handling/mod.rs

use crate::dynamic_data::script_handling::script::{Script, ScriptContainer};
use crate::dynamic_data::script_handling::script_set::ScriptSet;
use parking_lot::RwLock;
use std::sync::{Arc, Weak};

pub mod item_script;
pub mod script;
pub mod script_set;
pub mod volatile_scripts;

#[macro_export]
macro_rules! script_hook {
    ($hook_name: ident, $source: ident, $($parameters: expr),*) => {
        let mut aggregator = $source.get_script_iterator();
        while let Some(script_container) = aggregator.get_next() {
            let script = script_container.get();
            if let Some(script) = script {
                if let Some(script) = script.read().as_deref() {
                    if !script.is_suppressed() {
                        script.$hook_name($($parameters),*);
                    }
                }
            }
        }
    };
}

#[macro_export]
macro_rules! script_hook_on_lock {
    ($hook_name: ident, $source: ident, $($parameters: expr),*) => {
        let mut aggregator = $source.read().get_script_iterator();
        while let Some(script) = aggregator.get_next() {
            let lock = &mut script.get().read();
            let script = lock.as_mut().unwrap();
            if script.is_suppressed() {
                continue;
            }
            script.$hook_name($($parameters),*);
        }
    };
}

#[macro_export]
macro_rules! run_scripts {
    ($hook_name: ident, $source: ident, $($parameters: expr),*) => {
        for script in $source {
            match script {
                ScriptWrapper::Script(s) => {
                    if let Some(s) = s.upgrade() {
                        let s = s.read();
                        if let Some(s) = s.deref() {
                            if !s.is_suppressed() {
                                s.$hook_name($($parameters),*);
                            }
                        }
                    }
                }
                ScriptWrapper::Set(s) => {
                    if let Some(set) = s.upgrade() {
                        let current_scripts = set.get_owning_iterator();
                        for s in current_scripts {
                            if let Some(s) = s.get() {
                                let s = s.read();
                                if let Some(s) = s.deref() {
                                    if !s.is_suppressed() && set.has(s.name()) {
                                        s.$hook_name($($parameters),*);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    };
}

#[derive(Default, Debug)]
pub struct ScriptSourceData {
    is_initialized: bool,
    scripts: Vec<ScriptWrapper>,
}

pub trait ScriptSource<'a> {
    fn get_script_iterator(&self) -> ScriptAggregator {
        let lock = self.get_script_source_data();
        if !lock.read().is_initialized {
            let mut data = lock.write();
            data.scripts = Vec::with_capacity(self.get_script_count());
            self.collect_scripts(&mut data.scripts);
            data.is_initialized = true;
        }
        ScriptAggregator::new(&lock.read().scripts as *const Vec<ScriptWrapper>)
    }
    fn get_script_count(&self) -> usize;
    fn get_script_source_data(&self) -> &RwLock<ScriptSourceData>;
    fn get_own_scripts(&self, scripts: &mut Vec<ScriptWrapper>);
    fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>);
}

#[derive(Debug)]
pub enum ScriptWrapper {
    Script(Weak<RwLock<Option<Arc<dyn Script>>>>),
    Set(Weak<ScriptSet>),
}

impl From<&ScriptContainer> for ScriptWrapper {
    fn from(c: &ScriptContainer) -> Self {
        ScriptWrapper::Script(Arc::downgrade(c.arc()))
    }
}

impl From<&Arc<ScriptSet>> for ScriptWrapper {
    fn from(c: &Arc<ScriptSet>) -> Self {
        ScriptWrapper::Set(Arc::downgrade(c))
    }
}

pub struct ScriptAggregator {
    scripts: *const Vec<ScriptWrapper>,
    size: i32,
    index: i32,
    set_index: i32,
}

impl ScriptAggregator {
    pub fn new(scripts: *const Vec<ScriptWrapper>) -> Self {
        unsafe {
            let len = scripts.as_ref().unwrap().len();
            Self {
                scripts,
                size: len as i32,
                index: -1,
                set_index: -1,
            }
        }
    }

    fn increment_to_next_value(&mut self) -> bool {
        if self.index != -1 {
            let wrapper = unsafe { &self.scripts.as_ref().unwrap()[self.index as usize] };
            if let ScriptWrapper::Set(set) = wrapper {
                if let Some(set) = set.upgrade() {
                    self.set_index += 1;
                    if self.set_index as usize >= set.count() {
                        self.set_index = -1;
                    } else {
                        return true;
                    }
                }
            }
        }
        self.index += 1;
        for index in self.index..self.size {
            self.index = index;
            let wrapper = unsafe { &self.scripts.as_ref().unwrap()[self.index as usize] };
            if let ScriptWrapper::Set(s) = wrapper {
                if let Some(set) = s.upgrade() {
                    if set.count() > 0 {
                        self.set_index = 0;
                        return true;
                    }
                }
            } else if let ScriptWrapper::Script(script) = wrapper {
                if let Some(v) = script.upgrade() {
                    if let Some(..) = v.read().as_ref() {
                        return true;
                    }
                }
            }
        }

        false
    }

    pub fn get_next(&mut self) -> Option<ScriptContainer> {
        if !self.increment_to_next_value() {
            return None;
        }
        unsafe {
            return match &self.scripts.as_ref().unwrap()[self.index as usize] {
                // increment_to_next_value
                ScriptWrapper::Script(script) => Some(script.upgrade().unwrap().into()),
                ScriptWrapper::Set(set) => {
                    let set = set.upgrade().unwrap();
                    let sc = set.at(self.set_index as usize);
                    return Some(sc.clone());
                }
            };
        }
    }

    pub fn reset(&mut self) {
        self.index = -1;
        self.set_index = -1;
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::dynamic_data::script_handling::script::ScriptContainer;
    use crate::static_data::EffectParameter;
    use crate::StringKey;
    use std::any::Any;
    use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};

    pub struct TestScript {
        name: StringKey,
        is_marked_for_deletion: AtomicBool,
        suppressed_count: AtomicUsize,
        test_count: AtomicUsize,
    }

    impl TestScript {
        fn new() -> Self {
            Self {
                name: StringKey::new("test"),
                is_marked_for_deletion: Default::default(),
                suppressed_count: AtomicUsize::new(0),
                test_count: AtomicUsize::new(0),
            }
        }
        fn new_with_name(name: &str) -> Self {
            Self {
                name: StringKey::new(name),
                is_marked_for_deletion: Default::default(),
                suppressed_count: AtomicUsize::new(0),
                test_count: AtomicUsize::new(0),
            }
        }
    }

    impl Script for TestScript {
        fn name(&self) -> &StringKey {
            &self.name
        }

        fn get_marked_for_deletion(&self) -> &AtomicBool {
            &self.is_marked_for_deletion
        }

        fn get_suppressed_count(&self) -> &AtomicUsize {
            &self.suppressed_count
        }

        fn add_suppression(&self) {}

        fn remove_suppression(&self) {}

        fn on_initialize(&self, _pars: &[EffectParameter]) {
            self.test_count.fetch_add(1, Ordering::SeqCst);
        }

        fn as_any(&self) -> &dyn Any {
            self
        }

        fn as_any_mut(&mut self) -> &mut dyn Any {
            self
        }
    }

    #[test]
    fn script_aggregator_property_iterates_single_script() {
        let script = ScriptContainer::new(Arc::new(TestScript::new()));
        let scripts = vec![ScriptWrapper::from(&script)];
        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
        while let Some(v) = aggregator.get_next() {
            v.get().unwrap().read().as_ref().unwrap().on_initialize(&[]);
        }
        let a = script.get_as::<TestScript>();
        assert_eq!(a.test_count.load(Ordering::Relaxed), 1);
    }

    #[test]
    fn script_aggregator_property_iterates_single_script_with_resets() {
        let script = ScriptContainer::new(Arc::new(TestScript::new()));
        let scripts = vec![ScriptWrapper::from(&script)];
        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
        for i in 1..11 {
            aggregator.reset();
            while let Some(v) = aggregator.get_next() {
                v.get().unwrap().read().as_ref().unwrap().on_initialize(&[]);
            }
            let a = script.get_as::<TestScript>();
            assert_eq!(a.test_count.load(Ordering::Relaxed), i);
        }
    }

    #[test]
    fn script_aggregator_property_iterates_three_script() {
        let script1 = ScriptContainer::new(Arc::new(TestScript::new()));
        let script2 = ScriptContainer::new(Arc::new(TestScript::new()));
        let script3 = ScriptContainer::new(Arc::new(TestScript::new()));
        let scripts = vec![
            ScriptWrapper::from(&script1),
            ScriptWrapper::from(&script2),
            ScriptWrapper::from(&script3),
        ];
        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
        while let Some(v) = aggregator.get_next() {
            v.get().unwrap().read().as_ref().unwrap().on_initialize(&[]);
        }
        let a = script1.get_as::<TestScript>();
        assert_eq!(a.test_count.load(Ordering::Relaxed), 1);
        let a = script2.get_as::<TestScript>();
        assert_eq!(a.test_count.load(Ordering::Relaxed), 1);
        let a = script3.get_as::<TestScript>();
        assert_eq!(a.test_count.load(Ordering::Relaxed), 1);
    }

    #[test]
    fn script_aggregator_property_iterates_three_script_with_resets() {
        let script1 = ScriptContainer::new(Arc::new(TestScript::new()));
        let script2 = ScriptContainer::new(Arc::new(TestScript::new()));
        let script3 = ScriptContainer::new(Arc::new(TestScript::new()));
        let scripts = vec![
            ScriptWrapper::from(&script1),
            ScriptWrapper::from(&script2),
            ScriptWrapper::from(&script3),
        ];
        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
        for i in 1..11 {
            aggregator.reset();
            while let Some(v) = aggregator.get_next() {
                v.get().unwrap().read().as_ref().unwrap().on_initialize(&[]);
            }
            let a = script1.get_as::<TestScript>();
            assert_eq!(a.test_count.load(Ordering::Relaxed), i);
            let a = script2.get_as::<TestScript>();
            assert_eq!(a.test_count.load(Ordering::Relaxed), i);
            let a = script3.get_as::<TestScript>();
            assert_eq!(a.test_count.load(Ordering::Relaxed), i);
        }
    }

    #[test]
    fn script_aggregator_property_iterates_script_set() {
        let set = Arc::new(ScriptSet::default());
        set.add(Arc::new(TestScript::new_with_name("test_a")));
        set.add(Arc::new(TestScript::new_with_name("test_b")));
        set.add(Arc::new(TestScript::new_with_name("test_c")));

        let scripts = vec![ScriptWrapper::from(&set)];
        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
        for i in 1..11 {
            aggregator.reset();
            while let Some(v) = aggregator.get_next() {
                v.get().unwrap().read().as_ref().unwrap().on_initialize(&[]);
            }
            let s = set.at(0);
            let s = s.get_as::<TestScript>();
            assert_eq!(s.test_count.load(Ordering::Relaxed), i);
            assert_eq!(s.name().str(), "test_a");
            let s = set.at(1);
            let s = s.get_as::<TestScript>();
            assert_eq!(s.test_count.load(Ordering::Relaxed), i);
            assert_eq!(s.name().str(), "test_b");
            let s = set.at(2);
            let s = s.get_as::<TestScript>();
            assert_eq!(s.test_count.load(Ordering::Relaxed), i);
            assert_eq!(s.name().str(), "test_c");
        }
    }

    #[test]
    fn script_aggregator_property_iterates_script_set_when_removing_last() {
        let set = Arc::new(ScriptSet::default());
        set.add(Arc::new(TestScript::new_with_name("test_a")));
        set.add(Arc::new(TestScript::new_with_name("test_b")));
        set.add(Arc::new(TestScript::new_with_name("test_c")));

        let scripts = vec![ScriptWrapper::from(&set)];
        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
        assert_eq!(
            aggregator
                .get_next()
                .unwrap()
                .get()
                .unwrap()
                .read()
                .as_ref()
                .unwrap()
                .name()
                .str(),
            "test_a"
        );
        assert_eq!(
            aggregator
                .get_next()
                .unwrap()
                .get()
                .unwrap()
                .read()
                .as_ref()
                .unwrap()
                .name()
                .str(),
            "test_b"
        );

        set.remove(&StringKey::new("test_c"));
        assert!(aggregator.get_next().is_none());
    }

    #[test]
    fn script_aggregator_property_iterates_script_set_when_removing_middle() {
        let set = Arc::new(ScriptSet::default());
        set.add(Arc::new(TestScript::new_with_name("test_a")));
        set.add(Arc::new(TestScript::new_with_name("test_b")));
        set.add(Arc::new(TestScript::new_with_name("test_c")));

        let scripts = vec![ScriptWrapper::from(&set)];
        let mut aggregator = ScriptAggregator::new(&scripts as *const Vec<ScriptWrapper>);
        assert_eq!(
            aggregator
                .get_next()
                .unwrap()
                .get()
                .unwrap()
                .read()
                .as_ref()
                .unwrap()
                .name()
                .str(),
            "test_a"
        );

        set.remove(&StringKey::new("test_b"));

        assert_eq!(
            aggregator
                .get_next()
                .unwrap()
                .get()
                .unwrap()
                .read()
                .as_ref()
                .unwrap()
                .name()
                .str(),
            "test_c"
        );
        assert!(aggregator.get_next().is_none());
    }

    pub struct TestScriptSource {
        pub data: RwLock<ScriptSourceData>,
        pub script: ScriptContainer,
    }

    impl<'a> ScriptSource<'a> for TestScriptSource {
        fn get_script_count(&self) -> usize {
            1
        }

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

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

        fn collect_scripts(&self, scripts: &mut Vec<ScriptWrapper>) {
            self.get_own_scripts(scripts);
        }
    }

    #[test]
    fn script_source_set_script_then_rerun() {
        let source = TestScriptSource {
            data: RwLock::new(ScriptSourceData::default()),
            script: ScriptContainer::default(),
        };

        let mut aggregator = source.get_script_iterator();
        aggregator.reset();
        assert!(aggregator.get_next().is_none());
        aggregator.reset();
        source.script.set(Arc::new(TestScript::new()));
        assert!(aggregator.get_next().is_some());
    }

    #[test]
    fn script_source_clear_script_then_rerun() {
        let source = TestScriptSource {
            data: RwLock::new(ScriptSourceData::default()),
            script: ScriptContainer::default(),
        };

        let mut aggregator = source.get_script_iterator();
        source.script.set(Arc::new(TestScript::new()));
        assert!(aggregator.get_next().is_some());
        aggregator.reset();
        source.script.clear();
        assert!(aggregator.get_next().is_none());
    }
}