use crate::dynamic_data::script_handling::script::Script;
use crate::{PkmnResult, StringKey};
use indexmap::IndexMap;
use std::sync::Arc;

#[derive(Debug, Default)]
pub struct ScriptSet {
    scripts: IndexMap<StringKey, Arc<Box<dyn Script>>>,
}

impl ScriptSet {
    pub fn add(&mut self, script: Box<dyn Script>) -> Arc<Box<dyn Script>> {
        if let Some(existing) = self.scripts.get(script.name()) {
            existing.stack();
            return existing.clone();
        }
        let arc = Arc::new(script);
        self.scripts.insert(arc.name().clone(), arc.clone());
        self.scripts.last().unwrap().1.clone()
    }

    pub fn stack_or_add<'b, F>(
        &mut self,
        key: &StringKey,
        instantiation: &'b F,
    ) -> PkmnResult<Option<Arc<Box<dyn Script>>>>
    where
        F: Fn() -> PkmnResult<Option<Box<dyn Script>>>,
    {
        if let Some(existing) = self.scripts.get(key) {
            existing.stack();
            return Ok(Some(existing.clone()));
        }
        let script = instantiation()?;
        if let Some(script) = script {
            let arc = Arc::new(script);
            self.scripts.insert(arc.name().clone(), arc.clone());
            Ok(Some(self.scripts.last().unwrap().1.clone()))
        } else {
            Ok(None)
        }
    }

    pub fn get(&self, key: &StringKey) -> Option<&Arc<Box<dyn Script>>> {
        self.scripts.get(key)
    }

    pub fn remove(&mut self, key: &StringKey) {
        let value = self.scripts.shift_remove(key);
        if let Some(script) = value {
            script.on_remove();
        }
    }

    pub fn clear(&mut self) {
        for script in &self.scripts {
            script.1.on_remove();
        }
        self.scripts.clear();
    }

    pub fn has(&self, key: &StringKey) -> bool {
        self.scripts.contains_key(key)
    }

    pub fn at(&self, index: usize) -> &Arc<Box<dyn Script>> {
        &self.scripts[index]
    }

    pub fn count(&self) -> usize {
        self.scripts.len()
    }
}