use anyhow::Context as _;

use radicle::prelude::*;

use radicle::storage::WriteStorage;

use crate::project;

Options

    --no-confirm    Don't ask for confirmation during checkout

    --help          Print help

"#,

pub struct Options {

    pub id: Id,

}

impl Args for Options {

        let mut parser = lexopt::Parser::from_args(args);

        let mut id = None;

        while let Some(arg) = parser.next()? {

            match arg {

                    // Ignored for now.

                }

                Long("help") => return Err(Error::Help.into()),

                Value(val) if id.is_none() => {

                    let val = val.to_string_lossy();

                    let val = Id::from_str(&val).context(format!("invalid id '{}'", val))?;

        Ok((

            Options {

                id: id.ok_or_else(|| anyhow!("a project id to checkout must be provided"))?,

            },

            vec![],

        ))

pub fn execute(options: Options, profile: &Profile) -> anyhow::Result<PathBuf> {

    let id = options.id;

    let storage = &profile.storage;

    let doc = storage

        .repository(id)?

        .context("project could not be found in local storage")?;

    let payload = doc.project()?;

    let path = PathBuf::from(payload.name().clone());

    if path.exists() {

        anyhow::bail!("the local path {:?} already exists", path.as_path());

    }

    ));

    let spinner = term::spinner("Performing checkout...");

        Ok(repo) => repo,

        Err(err) => {

            spinner.failed();

pub fn clone(id: Id, _interactive: Interactive, ctx: impl term::Context) -> anyhow::Result<()> {

    let profile = ctx.profile()?;

    let signer = term::signer(&profile)?;

    // Track & fetch project.

    node.track_repo(id).context("track")?;

    // Create a local fork of the project, under our own id.

    let doc = profile

        .storage

    let storage = &profile.storage;

    let (_, rid) = radicle::rad::cwd().context("this command must be run within a project")?;

    let project = storage.repository(rid)?.project_of(profile.id())?;

    term::info!(

        "Establishing 🌱 tracking relationship for {}",

}

pub fn untrack(id: Id, profile: &Profile) -> anyhow::Result<bool> {

    node.untrack_repo(id).map_err(|e| anyhow!(e))

}

use std::{io, net, thread, time};

use crossbeam_channel as chan;

        }

        let reactor = Reactor::named(wire, popol::Poller::new(), id.to_human())?;

        let handle = Handle::new(home, reactor.controller());

        let control = thread::spawn({

            let handle = handle.clone();

        });

        let pool = WorkerPool::with(

    type Sessions = Sessions;

    type Error = Error;

    fn connect(&mut self, node: NodeId, addr: radicle::node::Address) -> Result<(), Error> {

        self.command(service::Command::Connect(node, addr))?;

use std::io::LineWriter;

use std::os::unix::net::UnixListener;

use std::os::unix::net::UnixStream;

use radicle::node::Handle;

}

/// Listen for commands on the control socket, and process them.

    mut handle: H,

) -> Result<(), Error> {

    for incoming in listener.incoming() {

        match incoming {

            Ok(mut stream) => {

                    stream.flush().ok();

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

                }

            }

            Err(e) => log::error!("Failed to accept incoming connection: {}", e),

        }

    }

    log::debug!("Exiting control loop..");

    Ok(())

}

#[derive(thiserror::Error, Debug)]

enum DrainError {

    #[error("unknown command `{0}`")]

    UnknownCommand(String),

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

) -> Result<(), DrainError> {

    let mut reader = BufReader::new(stream);

    let mut writer = LineWriter::new(stream);

    // TODO: refactor to include helper

            }

                    }

                }

            }

                    }

                }

            }

                        }

                    }

                }

            }

                    }

                }

            }

                }

            }

                    }

                }

                }

            },

    }

    Ok(())

}

            writeln!(

                writer,

                seeds.len(),

                &id,

                &seeds,

            )?;

                match result.result {

                    Ok(updated) => {

                        writeln!(writer, "ok: {} fetched from {}", &id, result.remote)?;

mod tests {

    use std::io::prelude::*;

    use std::os::unix::net::UnixStream;

    use super::*;

    use crate::identity::Id;

        let handle = test::handle::Handle::default();

        let socket = tmp.path().join("alice.sock");

        let projs = test::arbitrary::set::<Id>(1..3);

        thread::spawn({

            let handle = handle.clone();

        });

        for proj in &projs {

        }

        for proj in &projs {

            assert!(handle.updates.lock().unwrap().contains(proj));

        }

        let socket = tmp.path().join("node.sock");

        let proj = test::arbitrary::gen::<Id>(1);

        let peer = test::arbitrary::gen::<NodeId>(1);

        thread::spawn({

            let handle = crate::test::handle::Handle::default();

        });

        assert!(handle.track_repo(proj).unwrap());

        assert!(!handle.track_repo(proj).unwrap());

                }

                let seeds = match self.routing.get(&id) {

                    Err(err) => {

                        log::error!("Error reading routing table for {id}: {err}");

                        resp.send(FetchLookup::NotFound).ok();

                        return;

                    }

                };

                    resp.send(FetchLookup::NotFound).ok();

                    return;

                };

                let (results_send, results) = chan::bounded(seeds.len());

                resp.send(FetchLookup::Found {

                // TODO: Limit the number of seeds we fetch from? Randomize?

                for seed in seeds {

                }

            }

            Command::TrackRepo(id, resp) => {

        }

    }

        if let Some(fetch) = session.fetch(rid) {

            debug!("Fetch initiated for {rid} with {seed}..");

        } else {

            // TODO: If we can't fetch, it's because we're already fetching from

            // this peer. So we need to queue the request, or find another peer.

                    // Refs are only supposed to be relayed by peers who are tracking

                    // the resource. Therefore, it's safe to fetch from the remote

                    // peer, even though it isn't the announcer.

                    return Ok(true);

                } else {

    /// Error with an underlying established connection. Sometimes, reconnecting

    /// after such an error is possible.

    Connection(Arc<dyn std::error::Error + Sync + Send>),

    Session(session::Error),

}

    type Error = Error;

    type Sessions = service::Sessions;

    fn connect(&mut self, _node: NodeId, _addr: radicle::node::Address) -> Result<(), Error> {

        unimplemented!();

    }

                log::error!(target: "wire", "Received error: peer {} disconnected: {}", id, err);

                self.actions.push_back(Action::UnregisterTransport(*id));

            }

            reactor::Error::TransportDisconnect(id, _, err) => {

                log::error!(target: "wire", "Received error: peer {} disconnected: {}", id, err);

            }

            reactor::Error::WriteFailure(id, err) => {

            let result = self.fetch(fetch, &mut tunnel);

            let session = tunnel.into_session();

            (session, result)

        } else {

            log::debug!(target: "worker", "Worker processing incoming fetch for {}", fetch.repo);

            let result = self.upload_pack(fetch, drain, &mut stream_r, &mut stream_w);

            let session = WireSession::from_split_io(stream_r, stream_w);

            (session, result)

        }

    }

        let status = child.wait()?;

        // TODO: Parse fetch output to return updates.

        if let Some(status) = status.code() {

            log::debug!(target: "worker", "Fetch for {} exited with status {:?}", fetch.repo, status);

        } else {

        thread::scope(|scope| {

            // Data coming from the remote peer is written to the standard input of the

            // `upload-pack` process.

            let t = scope.spawn(move || io::copy(&mut reader, &mut stdin));

            // Output of `upload-pack` is sent back to the remote peer.

            io::copy(&mut stdout, stream_w)?;

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

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

#[derive(Debug, Error)]

pub enum Error {

                //    won't match the remote we're pushing to.

                let signer = if *service == GIT_RECEIVE_PACK {

                    if profile.public_key != namespace {

                    }

                    let signer = profile.signer()?;

                } else {

                    None

                };

                println!(); // Empty line signifies connection is established.

                let mut child = process::Command::new(service)

                    .stdin(process::Stdio::inherit())

                    .spawn()?;

                    if let Some(signer) = signer {

                        proj.sign_refs(&signer)?;

                        proj.set_head()?;

                        // 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.

                        }

                    }

                }

    if let Some(id) = env::args().nth(1) {

        let id = Id::from_urn(&id)?;

        let repo = radicle::rad::clone(id, &cwd, &signer, &profile.storage, &mut node)?;

        println!(

    let sigrefs = project.sign_refs(&signer)?;

    let head = project.set_head()?;

    println!("head: {}", head);

    println!("ok: {}", sigrefs.signature);

    url: &Url,

) -> Result<git2::Remote<'r>, git2::Error> {

    let fetch = format!("+refs/heads/*:refs/remotes/{name}/*");

    Ok(remote)

}

#[cfg(any(test, feature = "test"))]

pub mod test;

pub use profile::Profile;

pub use storage::git::Storage;

use std::io::{BufRead, BufReader, Write};

use std::ops::Deref;

use std::os::unix::net::UnixStream;

use std::{io, net};

use crossbeam_channel as chan;

    /// The error returned by all methods.

    type Error: std::error::Error;

    /// Connect to a peer.

    fn connect(&mut self, node: NodeId, addr: Address) -> Result<(), Self::Error>;

    /// Retrieve or update the project from network.

/// Node controller.

#[derive(Debug)]

pub struct Node {

}

impl Node {

    /// Connect to the node, via the socket at the given path.

    }

    /// Call a command on the node.

        &self,

        cmd: &str,

        args: &[A],

        let args = args

            .iter()

            .map(ToString::to_string)

            .collect::<Vec<_>>()

            .join(" ");

    }

}

    type Sessions = ();

    type Error = Error;

    fn connect(&mut self, _node: NodeId, _addr: Address) -> Result<(), Error> {

        todo!()

    }

            let line = line?;

            log::debug!("node: {}", line);

        }

    }

    fn track_node(&mut self, id: NodeId, alias: Option<String>) -> Result<bool, Error> {

        todo!();

    }

}

    raw.reference(

        &canonical_branch.with_namespace(me.into()),

        *canonical_head,

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

    )?;

    raw.reference(

        &git::refs::storage::id(me),

        canonical_id.into(),

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

    )?;

    repository.sign_refs(signer)?;

        }

    }

    let _ = fork(proj, signer, storage)?;

    let working = checkout(proj, signer.public_key(), path, storage)?;

    Ok(working)