use crate::collections::RandomMap;

use crate::storage::refs::Refs;

/// List remote refs of a project, given the remote URL.

pub fn remote_refs(url: &Url) -> Result<RandomMap<RemoteId, Refs>, ListRefsError> {

    let url = url.to_string();

    let mut remotes = RandomMap::default();

    let mut remote = raw::Remote::create_detached(url)?;

    remote.connect(raw::Direction::Fetch)?;

    let refs = remote.list()?;

    for r in refs {

        // Skip the `HEAD` reference, as it is untrusted.

        if r.name() == "HEAD" {

            continue;

        }

        // Nb. skip refs that don't have a public key namespace.

        if let (Some(id), refname) = parse_ref::<PublicKey>(r.name())? {

            let entry = remotes.entry(id).or_insert_with(Refs::default);

            entry.insert(refname.into(), r.oid().into());

        }

    }

    Ok(remotes)

}

    fn test_remote_refs() {

        let dir = tempfile::tempdir().unwrap();

        let signer = Device::mock();

        let storage = fixtures::storage(dir.path(), &signer).unwrap();

        let inv = storage.repositories().unwrap();

        let proj = inv.first().unwrap();

        let mut refs = git::remote_refs(&git::Url::from(proj.rid)).unwrap();

        let project = storage.repository(proj.rid).unwrap();

        let remotes = project.remotes().unwrap();

        // Strip the remote refs of sigrefs so we can compare them.

        for remote in refs.values_mut() {

            let sigref = (*SIGREFS_BRANCH).to_ref_string();

            remote.remove(&sigref).unwrap();

        }

        let remotes = remotes

            .map(|remote| remote.map(|(id, r): (RemoteId, Remote<Verified>)| (id, r.refs.into())))

            .collect::<Result<_, _>>()

            .unwrap();

        assert_eq!(refs, remotes);

    }

    #[test]