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) = aggregator.get_next() {
            let lock = &mut script.get();
            let script = lock.as_mut().unwrap();
            if script.is_suppressed() {
                continue;
            }
            script.$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<Box<dyn Script>>>>),
    Set(Weak<RwLock<ScriptSet>>),
}

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

impl From<&Arc<RwLock<ScriptSet>>> for ScriptWrapper {
    fn from(c: &Arc<RwLock<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.read().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(..) = s.upgrade() {
                    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 lock = set.as_ptr().as_ref().unwrap();
                    let l = lock.read();
                    let sc = l.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;

    pub struct TestScript {
        name: StringKey,
        test_count: usize,
    }

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

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

        fn get_suppressed_count(&self) -> usize {
            0
        }

        fn add_suppression(&mut self) {}

        fn remove_suppression(&mut self) {}

        fn on_initialize(&mut self, _pars: &[EffectParameter]) {
            self.test_count += 1;
        }

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

    #[test]
    fn script_aggregator_property_iterates_single_script() {
        let script = ScriptContainer::new(Box::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().as_mut().unwrap().on_initialize(&[]);
        }
        let a = script.get_as::<TestScript>();
        assert_eq!(a.test_count, 1);
    }

    #[test]
    fn script_aggregator_property_iterates_single_script_with_resets() {
        let script = ScriptContainer::new(Box::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().as_mut().unwrap().on_initialize(&[]);
            }
            let a = script.get_as::<TestScript>();
            assert_eq!(a.test_count, i);
        }
    }

    #[test]
    fn script_aggregator_property_iterates_three_script() {
        let script1 = ScriptContainer::new(Box::new(TestScript::new()));
        let script2 = ScriptContainer::new(Box::new(TestScript::new()));
        let script3 = ScriptContainer::new(Box::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().as_mut().unwrap().on_initialize(&[]);
        }
        let a = script1.get_as::<TestScript>();
        assert_eq!(a.test_count, 1);
        let a = script2.get_as::<TestScript>();
        assert_eq!(a.test_count, 1);
        let a = script3.get_as::<TestScript>();
        assert_eq!(a.test_count, 1);
    }

    #[test]
    fn script_aggregator_property_iterates_three_script_with_resets() {
        let script1 = ScriptContainer::new(Box::new(TestScript::new()));
        let script2 = ScriptContainer::new(Box::new(TestScript::new()));
        let script3 = ScriptContainer::new(Box::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().as_mut().unwrap().on_initialize(&[]);
            }
            let a = script1.get_as::<TestScript>();
            assert_eq!(a.test_count, i);
            let a = script2.get_as::<TestScript>();
            assert_eq!(a.test_count, i);
            let a = script3.get_as::<TestScript>();
            assert_eq!(a.test_count, i);
        }
    }

    #[test]
    fn script_aggregator_property_iterates_script_set() {
        let set = Arc::new(RwLock::new(ScriptSet::default()));
        let mut mut_set = set.write();
        mut_set.add(Box::new(TestScript::new_with_name("test_a")));
        mut_set.add(Box::new(TestScript::new_with_name("test_b")));
        mut_set.add(Box::new(TestScript::new_with_name("test_c")));
        // Drop so we don't have a lock on it anymore.
        drop(mut_set);

        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().as_mut().unwrap().on_initialize(&[]);
            }
            let set = set.read();
            let s = set.at(0).get_as::<TestScript>();
            assert_eq!(s.test_count, i);
            assert_eq!(s.name().str(), "test_a");
            let s = set.at(1).get_as::<TestScript>();
            assert_eq!(s.test_count, i);
            assert_eq!(s.name().str(), "test_b");
            let s = set.at(2).get_as::<TestScript>();
            assert_eq!(s.test_count, i);
            assert_eq!(s.name().str(), "test_c");
        }
    }

    #[test]
    fn script_aggregator_property_iterates_script_set_when_removing_last() {
        let set = Arc::new(RwLock::new(ScriptSet::default()));
        let mut mut_set = set.write();
        mut_set.add(Box::new(TestScript::new_with_name("test_a")));
        mut_set.add(Box::new(TestScript::new_with_name("test_b")));
        mut_set.add(Box::new(TestScript::new_with_name("test_c")));
        // Drop so we don't have a lock on it anymore.
        drop(mut_set);

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

        let mut mut_set = set.write();
        mut_set.remove(&StringKey::new("test_c"));
        drop(mut_set);

        assert!(aggregator.get_next().is_none());
    }

    #[test]
    fn script_aggregator_property_iterates_script_set_when_removing_middle() {
        let set = Arc::new(RwLock::new(ScriptSet::default()));
        let mut mut_set = set.write();
        mut_set.add(Box::new(TestScript::new_with_name("test_a")));
        mut_set.add(Box::new(TestScript::new_with_name("test_b")));
        mut_set.add(Box::new(TestScript::new_with_name("test_c")));
        // Drop so we don't have a lock on it anymore.
        drop(mut_set);

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

        let mut mut_set = set.write();
        mut_set.remove(&StringKey::new("test_b"));
        drop(mut_set);

        assert_eq!(
            aggregator
                .get_next()
                .unwrap()
                .get()
                .as_mut()
                .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(Box::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(Box::new(TestScript::new()));
        assert!(aggregator.get_next().is_some());
        aggregator.reset();
        source.script.clear();
        assert!(aggregator.get_next().is_none());
    }
}