mod list {
    use std::path::Path;

    use gix_glob::{
        pattern::Case,
        search::{
            Pattern,
            pattern::{List, Mapping},
        },
    };

    #[derive(Clone, PartialEq, Eq, Debug, Hash, Ord, PartialOrd, Default)]
    struct Dummy;

    impl Pattern for Dummy {
        type Value = ();

        fn bytes_to_patterns(&self, _bytes: &[u8], _source: &Path) -> Vec<Mapping<Self::Value>> {
            vec![]
        }
    }

    #[test]
    fn from_bytes_base() {
        {
            let list = List::from_bytes(&[], "a/b/source".into(), None, Dummy);
            assert_eq!(list.base, None, "no root always means no-base, i.e. globals lists");
            assert_eq!(
                list.source.as_deref(),
                Some(Path::new("a/b/source")),
                "source is verbatim"
            );
        }

        {
            let cwd = std::env::current_dir().expect("cwd available");
            let list = List::from_bytes(&[], cwd.join("a/b/source"), Some(cwd.as_path()), Dummy);
            assert_eq!(
                list.base.as_ref().expect("set"),
                "a/b/",
                "bases are always relative, needs properly set root"
            );
            assert_eq!(
                list.source.as_deref(),
                Some(cwd.join("a/b/source").as_path()),
                "source is verbatim"
            );
        }

        {
            let list = List::from_bytes(&[], "a/b/source".into(), Some(Path::new("c/")), Dummy);
            assert_eq!(
                list.base, None,
                "if root doesn't contain source, it silently skips it as base"
            );
            assert_eq!(
                list.source.as_deref(),
                Some(Path::new("a/b/source")),
                "source is always verbatim"
            );
        }
    }

    #[test]
    fn strip_base_handle_recompute_basename_pos() {
        let list = List::from_bytes(&[], "a/b/source".into(), Some(Path::new("")), Dummy);
        assert_eq!(
            list.base.as_ref().expect("set"),
            "a/b/",
            "bases are computed if `root` is set, and always uses slashes"
        );
        let res = list.strip_base_handle_recompute_basename_pos("a/b/file".into(), Some(4), Case::Sensitive);
        assert_eq!(
            res,
            Some(("file".into(), None)),
            "files don't have a basename position anymore"
        );

        let res = list.strip_base_handle_recompute_basename_pos("a/B/c/File".into(), Some(6), Case::Fold);
        assert_eq!(
            res,
            Some(("c/File".into(), Some(2))),
            "otherwise the basename is recomputed, case folding is effective"
        );
    }

    #[test]
    fn from_file_that_does_not_exist() {
        let mut buf = Vec::new();
        for path in [
            Path::new(".").join("non-existing-dir").join("pattern-file"),
            Path::new("file").to_owned(),
        ] {
            let list = List::from_file(path, None, false, &mut buf, Dummy).expect("no io error");
            assert!(list.is_none(), "the file does not exist");
        }
    }

    #[test]
    fn from_file_that_is_a_directory() -> gix_testtools::Result<()> {
        let tmp = gix_testtools::tempfile::TempDir::new()?;
        let dir_path = tmp.path().join(".gitignore");
        std::fs::create_dir(&dir_path)?;
        let mut buf = Vec::new();
        let list = List::from_file(dir_path, None, false, &mut buf, Dummy).expect("no io error");
        assert!(list.is_none(), "directories are ignored just like Git does it");

        Ok(())
    }
}