use itertools::Itertools;
use schist_models::Bucket;

use crate::gui::components::Text;

pub fn view_group_names(buckets: Vec<Bucket>) -> Vec<Text> {
    buckets
        .iter()
        .map(|b| b.group.as_str())
        .unique()
        .map(Text::new)
        .collect()
}

#[cfg(test)]
mod test {
    use schist_fakes::bucket::make_fake_bucket_builder;

    use crate::gui::components::{balances_view::view_group_names::view_group_names, text::Text};

    #[test]
    fn preserves_order() {
        let buckets = vec![
            make_fake_bucket_builder(0)
                .group(String::from("hydrogen"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(1)
                .group(String::from("helium"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(2)
                .group(String::from("lithium"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(3)
                .group(String::from("beryllium"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(4)
                .group(String::from("boron"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(5)
                .group(String::from("carbon"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(6)
                .group(String::from("nitrogen"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(7)
                .group(String::from("oxygen"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(8)
                .group(String::from("flourine"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(8)
                .group(String::from("flourine"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(8)
                .group(String::from("neon"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(8)
                .group(String::from("magnesium"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(8)
                .group(String::from("aluminium"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(8)
                .group(String::from("silicon"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(8)
                .group(String::from("phosphorus"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(8)
                .group(String::from("sulphur"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(8)
                .group(String::from("chlorine"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(8)
                .group(String::from("argon"))
                .build()
                .unwrap(),
        ];
        let group_names = view_group_names(buckets);
        assert_eq!(17, group_names.len());
        assert_eq!(group_names[0], Text::new("hydrogen"));
        assert_eq!(group_names[1], Text::new("helium"));
        assert_eq!(group_names[2], Text::new("lithium"));
        assert_eq!(group_names[3], Text::new("beryllium"));
        assert_eq!(group_names[4], Text::new("boron"));
        assert_eq!(group_names[5], Text::new("carbon"));
        assert_eq!(group_names[6], Text::new("nitrogen"));
        assert_eq!(group_names[7], Text::new("oxygen"));
        assert_eq!(group_names[8], Text::new("flourine"));
        assert_eq!(group_names[9], Text::new("neon"));
        assert_eq!(group_names[10], Text::new("magnesium"));
        assert_eq!(group_names[11], Text::new("aluminium"));
        assert_eq!(group_names[12], Text::new("silicon"));
        assert_eq!(group_names[13], Text::new("phosphorus"));
        assert_eq!(group_names[14], Text::new("sulphur"));
        assert_eq!(group_names[15], Text::new("chlorine"));
        assert_eq!(group_names[16], Text::new("argon"));
    }

    #[test]
    fn removes_duplicates() {
        let buckets = vec![
            make_fake_bucket_builder(0)
                .group(String::from("hydrogen"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(1)
                .group(String::from("helium"))
                .build()
                .unwrap(),
            make_fake_bucket_builder(2)
                .group(String::from("hydrogen"))
                .build()
                .unwrap(),
        ];
        let group_names = view_group_names(buckets);
        assert_eq!(
            vec![
                Text::new("hydrogen"),
                Text::new("helium"),
            ],
            group_names
        );
    }
}