#[path = "commands/clone.rs"]

pub mod rad_clone;

    // Setup remote tracking branches for project delegates.

    setup_remotes(

pub fn setup_remotes(setup: project::SetupRemote, remotes: &[NodeId]) -> anyhow::Result<()> {

#![allow(clippy::or_fun_call)]

use std::ffi::OsString;

use std::path::Path;

use std::str::FromStr;

use anyhow::anyhow;

use anyhow::Context as _;

use radicle::node::Handle;

use radicle::prelude::*;

use radicle::rad;

use radicle::storage::WriteStorage;

use crate::commands::rad_checkout::setup_remotes;

use crate::project;

use crate::terminal as term;

use crate::terminal::args::{Args, Error, Help};

use crate::terminal::Interactive;

pub const HELP: Help = Help {

    name: "clone",

    description: "Clone radicle projects",

    version: env!("CARGO_PKG_VERSION"),

    usage: r#"

Usage

    rad clone <id> [<option>...]

Options

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

    --help          Print help

"#,

};

#[derive(Debug)]

pub struct Options {

    id: Id,

    interactive: Interactive,

}

impl Args for Options {

    fn from_args(args: Vec<OsString>) -> anyhow::Result<(Self, Vec<OsString>)> {

        use lexopt::prelude::*;

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

        let mut id: Option<Id> = None;

        let mut interactive = Interactive::Yes;

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

            match arg {

                Long("no-confirm") => {

                    interactive = Interactive::No;

                }

                Long("help") => {

                    return Err(Error::Help.into());

                }

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

                    let val = val.to_string_lossy();

                    let val = val.strip_prefix("rad://").unwrap_or(&val);

                    let val = Id::from_str(val)?;

                    id = Some(val);

                }

                _ => return Err(anyhow!(arg.unexpected())),

            }

        }

        let id = id.ok_or_else(|| {

            anyhow!("to clone, a radicle id must be provided; see `rad clone --help`")

        })?;

        Ok((Options { id, interactive }, vec![]))

    }

}

pub fn run(options: Options, ctx: impl term::Context) -> anyhow::Result<()> {

    clone(options.id, options.interactive, ctx)

}

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

    let profile = ctx.profile()?;

    let node = radicle::node::connect(profile.node())?;

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

    // Track & fetch project.

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

    node.fetch(&id).context("fetch")?;

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

    rad::fork(id, &signer, &profile.storage).context("fork")?;

    let doc = profile

        .storage

        .repository(id)?

        .project_of(profile.id())

        .map_err(|_e| anyhow!("couldn't load project {} from local state", id))?;

    let path = Path::new(&doc.name);

    let repo = rad::checkout(id, profile.id(), path, &profile.storage)?;

    let delegates = doc

        .delegates

        .iter()

        .map(|d| *d.id)

        .filter(|id| id != profile.id())

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

    let default_branch = doc.payload.default_branch.clone();

    // Setup tracking for project delegates.

    setup_remotes(

        project::SetupRemote {

            project: id,

            default_branch,

            repo: &repo,

            fetch: true,

            tracking: true,

        },

        &delegates,

    )?;

    term::headline(&format!(

        "🌱 Project successfully cloned under {}",

        term::format::highlight(Path::new(".").join(path).display())

    ));

    Ok(())

}