use radicle::crypto::{PublicKey, Signer};

use radicle::node::Handle;

use radicle::ssh;

/// The service invoked by git on the remote repository, during a push.

const GIT_RECEIVE_PACK: &str = "git-receive-pack";

                if child.wait()?.success() {

                    if *service == GIT_RECEIVE_PACK {

                        profile.storage.sign_refs(&proj, &profile.signer)?;

                        // Connect to local node and announce refs to the network.

                        // If our node is not running, we simply skip this step, as the

                        // refs will be announced eventually, when the node restarts.

    let refs = remote.list()?;

    for r in refs {

    }

    Ok(remotes)

}

where

    T: FromStr,

    T::Err: std::error::Error + Send + Sync + 'static,

{

    let input = format::RefStr::try_from_str(s)?;

    match input.to_namespaced() {

        Some(ns) => {

            let id = ns

                .namespace()

                    err: Box::new(err),

                })?;

            let rest = ns.strip_namespace();

        }

    }

}

        let oid = git2::Oid::from_str("2d52a53ce5e4f141148a5f770cfd3ead2d6a45b8").unwrap();

        let err = Doc::<Unverified>::head(&remote, &repo).unwrap_err();

        let err = Doc::load_at(oid.into(), &repo).unwrap_err();

        assert!(err.is_not_found());

use std::path::Path;

use std::str::FromStr;

use once_cell::sync::Lazy;

use thiserror::Error;

pub enum InitError {

    #[error("doc: {0}")]

    Doc(#[from] identity::project::DocError),

    #[error("doc: {0}")]

    DocVerification(#[from] identity::project::VerificationError),

    #[error("git: {0}")]

    git::configure_remote(repo, &REMOTE_NAME, &url)?;

    git::push(repo, &REMOTE_NAME, pk, [(&default_branch, &default_branch)])?;

    let signed = storage.sign_refs(&project, signer)?;

    Ok((id, signed))

}

    let me = signer.public_key();

    let repository = storage.repository(proj)?;

    let (canonical_id, project) = repository.project_identity()?;

    let raw = repository.raw();

    raw.reference(

        &git::refs::storage::branch(me, &project.default_branch),

        false,

        &format!("creating default branch for {me}"),

    )?;

    Verify(#[from] git::VerifyError),

    #[error(transparent)]

    Storage(#[from] Error),

}

pub type RemoteId = PublicKey;

    type Repository: WriteRepository;

    fn repository(&self, proj: Id) -> Result<Self::Repository, Error>;

    fn sign_refs<G: Signer>(

        &self,

        repository: &Self::Repository,

    fn blob_at<'a>(&'a self, oid: Oid, path: &'a Path) -> Result<git2::Blob<'a>, git_ext::Error>;

    /// Get the `reference` for the given `remote`.

    ///

    /// Returns `None` is the reference did not exist.

pub trait WriteRepository: ReadRepository {

    fn fetch(&mut self, url: &Url) -> Result<Vec<RefUpdate>, FetchError>;

    fn raw(&self) -> &git2::Repository;

}

pub static SIGNATURES_GLOB: Lazy<refspec::PatternString> =

    Lazy::new(|| refspec::pattern!("refs/namespaces/*/radicle/signature"));

#[derive(Error, Debug)]

pub enum ProjectError {

    #[error("identity branches diverge from each other")]

        Ok(Self { id, backend })

    }

    pub fn verify(&self) -> Result<(), VerifyError> {

        let mut remotes: HashMap<RemoteId, Refs> = self

            .remotes()?

            })

            .collect::<Result<_, VerifyError>>()?;

        for r in self.backend.references()? {

            let r = r?;

            let name = r.name().ok_or(VerifyError::InvalidRef)?;

            let (remote_id, refname) = git::parse_ref::<RemoteId>(name)?;

            if refname == *refs::SIGNATURE_REF {

                continue;

            }

            let remote = remotes

                .get_mut(&remote_id)

                .ok_or(VerifyError::InvalidRemote(remote_id))?;

            |reference| -> Result<RemoteId, refs::Error> {

                let r = reference?;

                let name = r.name().ok_or(refs::Error::InvalidRef)?;

                Ok(id)

            },

            |reference| -> Result<_, _> {

                let r = reference?;

                let name = r.name().ok_or(refs::Error::InvalidRef)?;

                let remote = self.remote(&id)?;

                Ok((id, remote))

        remote: &RemoteId,

        reference: &git::Qualified,

    ) -> Result<Oid, git::Error> {

        let oid = self

            .reference(remote, reference)?

            .target()

    fn project_identity(&self) -> Result<(Oid, identity::Doc<Unverified>), ProjectError> {

        Repository::project(self)

    }

}

impl WriteRepository for Repository {

            // Fetch from the staging copy into the canonical repo.

            remote.fetch(refs, Some(&mut opts), None)?;

        }

        Ok(updates)

    }

    fn raw(&self) -> &git2::Repository {

        &self.backend

    }

            .id();

        git::push(&proj_repo, "rad", alice_id, [(&refname, &refname)]).unwrap();

        alice.sign_refs(&alice_proj_storage, &alice_signer).unwrap();

        // Have Bob fetch Alice's new commit.

        let updates = bob.repository(proj_id).unwrap().fetch(&alice_url).unwrap();

            target

                .remote_anonymous(&format!("rad://{}", proj))

                .unwrap()

                .unwrap();

            stream.shutdown(net::Shutdown::Both).unwrap();

use std::collections::HashMap;

use std::path::{Path, PathBuf};

use git_url::Url;

use radicle_git_ext as git_ext;

        Ok(true)

    }

    fn path(&self) -> &std::path::Path {

        todo!()

    }

    fn raw(&self) -> &git2::Repository {

        todo!()

    }

}