mod set_namespace {
    use git_repository as git;
    use git_repository::{prelude::ReferenceAccessExt, refs::transaction::PreviousValue};

    fn easy_repo_rw() -> crate::Result<(git::EasyArcExclusive, tempfile::TempDir)> {
        crate::repo_rw("make_references_repo.sh").map(|(r, d)| (r.into_easy_arc_exclusive(), d))
    }

    #[test]
    fn affects_edits_and_iteration() {
        let (mut repo, _keep) = easy_repo_rw().unwrap();
        assert_eq!(
            repo.references().unwrap().all().unwrap().count(),
            15,
            "there are plenty of references in the default namespace"
        );
        assert!(repo.namespace().unwrap().is_none(), "no namespace is set initially");
        assert!(
            repo.set_namespace("foo").unwrap().is_none(),
            "there is no previous namespace"
        );

        assert_eq!(
            repo.references().unwrap().all().unwrap().filter_map(Result::ok).count(),
            0,
            "no references are in the namespace yet"
        );

        repo.tag(
            "new-tag",
            git::hash::ObjectId::empty_tree(git::hash::Kind::Sha1),
            PreviousValue::MustNotExist,
        )
        .unwrap();

        repo.reference(
            "refs/heads/new-branch",
            git::hash::ObjectId::empty_tree(git::hash::Kind::Sha1),
            PreviousValue::MustNotExist,
            "message",
        )
        .unwrap();

        assert_eq!(
            repo.references()
                .unwrap()
                .all()
                .unwrap()
                .filter_map(Result::ok)
                .map(|r| r.name().as_bstr().to_owned())
                .collect::<Vec<_>>(),
            vec!["refs/heads/new-branch", "refs/tags/new-tag"],
            "namespaced references appear like normal ones"
        );

        assert_eq!(
            repo.references()
                .unwrap()
                .prefixed("refs/tags/")
                .unwrap()
                .filter_map(Result::ok)
                .map(|r| r.name().as_bstr().to_owned())
                .collect::<Vec<_>>(),
            vec!["refs/tags/new-tag"],
            "namespaced references appear like normal ones"
        );
        let fully_qualified_tag_name = "refs/tags/new-tag";
        assert_eq!(
            repo.find_reference(fully_qualified_tag_name).unwrap().name().as_bstr(),
            fully_qualified_tag_name,
            "fully qualified (yet namespaced) names work"
        );
        assert_eq!(
            repo.find_reference("new-tag").unwrap().name().as_bstr(),
            fully_qualified_tag_name,
            "namespaces are transparent"
        );

        let previous_ns = repo.clear_namespace().unwrap().expect("namespace set");
        assert_eq!(previous_ns.as_bstr(), "refs/namespaces/foo/");
        assert!(
            repo.clear_namespace().unwrap().is_none(),
            "it doesn't invent namespaces"
        );

        assert_eq!(
            repo.references().unwrap().all().unwrap().count(),
            17,
            "it lists all references, also the ones in namespaces"
        );
    }
}

mod iter_references {
    use git_repository as git;
    use git_repository::prelude::ReferenceAccessExt;

    fn repo() -> crate::Result<git::Easy> {
        crate::repo("make_references_repo.sh").map(|r| r.into_easy())
    }

    #[test]
    fn all() -> crate::Result {
        let repo = repo()?;
        assert_eq!(
            repo.references()?
                .all()?
                .filter_map(Result::ok)
                .map(|r| r.name().as_bstr().to_owned())
                .collect::<Vec<_>>(),
            vec![
                "refs/d1",
                "refs/heads/d1",
                "refs/heads/dt1",
                "refs/heads/main",
                "refs/heads/multi-link-target1",
                "refs/loop-a",
                "refs/loop-b",
                "refs/multi-link",
                "refs/remotes/origin/HEAD",
                "refs/remotes/origin/main",
                "refs/remotes/origin/multi-link-target3",
                "refs/tags/dt1",
                "refs/tags/multi-link-target2",
                "refs/tags/t1"
            ]
        );
        Ok(())
    }

    #[test]
    fn prefixed() -> crate::Result {
        let repo = repo()?;
        assert_eq!(
            repo.references()?
                .prefixed("refs/heads/")?
                .filter_map(Result::ok)
                .map(|r| r.name().as_bstr().to_owned())
                .collect::<Vec<_>>(),
            vec![
                "refs/heads/d1",
                "refs/heads/dt1",
                "refs/heads/main",
                "refs/heads/multi-link-target1",
            ]
        );
        Ok(())
    }
}

mod head {

    use git_ref::transaction::PreviousValue;
    use git_repository as git;
    use git_repository::prelude::ReferenceAccessExt;
    use git_testtools::hex_to_id;

    #[test]
    fn symbolic() -> crate::Result {
        let repo = crate::basic_repo()?;
        let head = repo.head()?;
        match &head.kind {
            git::easy::head::Kind::Symbolic(r) => {
                assert_eq!(
                    r.target.as_id().map(ToOwned::to_owned),
                    Some(hex_to_id("3189cd3cb0af8586c39a838aa3e54fd72a872a41"))
                );
            }
            _ => panic!("unexpected head kind"),
        }
        assert_eq!(head.name().expect("born").as_bstr(), "refs/heads/main");
        assert!(!head.is_detached());
        Ok(())
    }

    #[test]
    fn detached() -> crate::Result {
        let (repo, _keep) = crate::basic_rw_repo()?;
        repo.reference(
            "HEAD",
            hex_to_id("3189cd3cb0af8586c39a838aa3e54fd72a872a41"),
            PreviousValue::Any,
            "",
        )?;

        let head = repo.head()?;
        assert!(head.is_detached(), "head is detached");
        assert!(head.name().is_none());
        Ok(())
    }
}