use crate::static_data::libraries::data_library::DataLibrary;
use crate::static_data::species_data::species::Species;
use std::collections::HashMap;

#[derive(Debug)]
pub struct SpeciesLibrary<'a> {
    map: HashMap<String, Species<'a>>,
    list: Vec<String>,
}

impl<'a> SpeciesLibrary<'a> {
    pub fn new(capacity: usize) -> SpeciesLibrary<'a> {
        SpeciesLibrary {
            map: HashMap::with_capacity(capacity),
            list: Vec::with_capacity(capacity),
        }
    }
}

impl<'a> DataLibrary<'a, Species<'a>> for SpeciesLibrary<'a> {
    fn map(&self) -> &HashMap<String, Species<'a>> {
        &self.map
    }

    fn list_values(&self) -> &Vec<String> {
        &self.list
    }

    fn get_modify(&mut self) -> (&mut HashMap<String, Species<'a>>, &mut Vec<String>) {
        (&mut self.map, &mut self.list)
    }
}

#[cfg(test)]
pub mod tests {
    use crate::static_data::libraries::data_library::DataLibrary;
    use crate::static_data::libraries::species_library::SpeciesLibrary;
    use crate::static_data::species_data::form::Form;
    use crate::static_data::species_data::learnable_moves::LearnableMoves;
    use crate::static_data::species_data::species::Species;
    use crate::static_data::statistic_set::StatisticSet;
    use std::collections::HashSet;

    fn build_species<'a>() -> Species<'a> {
        Species::new(
            0,
            "foo",
            0.5,
            "",
            0,
            Form::new(
                "default",
                0.0,
                0.0,
                0,
                Vec::new(),
                StatisticSet::default(),
                Vec::new(),
                Vec::new(),
                LearnableMoves::new(),
                HashSet::new(),
            ),
            HashSet::new(),
        )
    }

    pub fn build<'a>() -> SpeciesLibrary<'a> {
        let mut lib = SpeciesLibrary::new(1);
        let species = build_species();
        // Borrow as mut so we can insert
        let w = &mut lib;
        w.add("foo", species);
        // Drops borrow as mut

        lib
    }

    #[test]
    fn add_species_to_library_and_fetch() {
        let lib = build();

        // Borrow as read so we can read
        let r = &lib;
        let mon = r.get("foo");
        assert!(mon.is_some());
        assert_eq!(*mon.unwrap().id(), 0_u16);
        assert_eq!(mon.unwrap().name(), "foo");
        assert_eq!(r.len(), 1);
    }

    #[test]
    fn add_species_to_library_then_remove() {
        let mut lib = build();

        lib.remove("foo");

        // Borrow as read so we can read
        let r = &lib;
        let mon = r.get("foo");
        assert!(mon.is_none());
        assert_eq!(r.len(), 0);
    }
}