//! Commands that talk to remotes, and the reference server.

use super::format::plural;

use super::json;

use super::open;

use super::ui;

use anyhow::{Context, Result};

use oxy_core::repo::Repo;

use std::path::PathBuf;

pub fn clone(

    url: &str,

    dest: Option<PathBuf>,

    max_blob: Option<&str>,

    sparse: &[String],

    depth: Option<u32>,

    recursive: bool,

) -> Result<i32> {

    let dest = dest.unwrap_or_else(|| {

        let base = url

            .trim_end_matches('/')

            .rsplit('/')

            .next()

            .unwrap_or("repo");

        PathBuf::from(base)

    });

    let max_blob = max_blob.map(oxy_core::repo::parse_size).transpose()?;

    let sp = ui::spinner(&format!("Cloning {url}…"));

    let repo = match depth {

        Some(d) => Repo::clone_shallow(url, &dest, d, max_blob, sparse)?,

        None => Repo::clone_with(url, &dest, max_blob, sparse)?,

    };

    let heads = repo.bookmark_heads()?;

    sp.done(&format!(

        "{} into {} {}",

        ui::done("Cloned"),

        ui::path(repo.root().display()),

        ui::dim(format!(

            "({url}, {} with {})",

            ui::bookmark(&repo.config.bookmark),

            plural(heads.len(), "head")

        ))

    ));

    let others = repo.remote_only_bookmarks()?.len();

    if others > 0 {

        println!(

            "  {} {}",

            ui::note(),

            ui::dim(format!(

                "origin has {} more: oxy bookmark list --all, then oxy bookmark switch NAME",

                plural(others, "bookmark")

            ))

        );

    }

    let subrepos = repo.subrepos()?.len();

    if subrepos == 0 {

        return Ok(0);

    }

    if recursive {

        let sp = ui::spinner("Cloning subrepos…");

        let results = repo.submodule_update(true, &[])?;

        sp.clear();

        return Ok(print_subrepo_results(results));

    }

    println!(

        "  {} {}",

        ui::note(),

        ui::dim(format!(

            "{} not cloned: oxy submodule update --init (or clone with --recursive)",

            plural(subrepos, "subrepo")

        ))

    );

    Ok(0)

}

/// After a switch or pull: say when subrepos are not at their pins.

pub fn subrepos_behind(repo: &Repo) {

    let Ok(subs) = repo.subrepos() else {

        return;

    };

    let stale = subs

        .iter()

        .filter(|s| s.committed && s.actual.as_ref() != Some(&s.pin))

        .count();

    if stale > 0 {

        println!(

            "  {} {}",

            ui::note(),

            ui::dim(format!(

                "{} not at {} pin: oxy submodule update --init",

                plural(stale, "subrepo"),

                if stale == 1 { "its" } else { "their" }

            ))

        );

    }

}

pub fn remote_add(name: &str, url: &str) -> Result<i32> {

    let mut repo = open()?;

    repo.config.set(

        &format!("remote.{name}.url"),

        &oxy_core::protocol::stored_url(url),

    )?;

    repo.save_config()?;

    println!(

        "{} remote {} {} {url}",

        ui::done("Added"),

        ui::bookmark(name),

        ui::dim(ui::glyph("→", "->"))

    );

    Ok(0)

}

pub fn remote_remove(name: &str) -> Result<i32> {

    let mut repo = open()?;

    repo.config.set(&format!("remote.{name}.url"), "")?;

    repo.save_config()?;

    println!("{} remote {}", ui::done("Removed"), ui::bookmark(name));

    Ok(0)

}

pub fn remote_list(as_json: bool) -> Result<i32> {

    let repo = open()?;

    let view = repo.view()?;

    if as_json {

        let items = repo.config.remotes.iter().map(|(name, url)| {

            let bms = view.remotes.get(name).map(|b| {

                json::arr(b.iter().map(|(bm, st)| {

                    let heads = repo

                        .store()

                        .get_state(st)

                        .map(|s| s.heads)

                        .unwrap_or_default();

                    json::obj([("name", json::s(bm)), ("heads", json::hashes(&heads))])

                }))

            });

            json::obj([

                ("name", json::s(name)),

                ("url", json::s(url)),

                // The CA file `remote.NAME.ca` names, for tools that talk to

                // the same hub (an editor's forge view, `oh`).

                (

                    "ca",

                    json::opt(repo.config.remote_cas.get(name), |c| json::s(c)),

                ),

                ("bookmarks", bms.unwrap_or_else(|| "[]".into())),

            ])

        });

        println!("{}", json::arr(items));

        return Ok(0);

    }

    if repo.config.remotes.is_empty() {

        println!(

            "{}",

            ui::dim("No remotes; add one with oxy remote add <name> <url>.")

        );

    }

    for (name, url) in &repo.config.remotes {

        println!(

            "{} {}{}{}",

            ui::ok(ui::glyph("⇄", "<>")),

            ui::bookmark(name),

            ui::sep(),

            ui::dim(url)

        );

        if let Some(bms) = view.remotes.get(name) {

            for (bm, st) in bms {

                let heads = repo

                    .store()

                    .get_state(st)

                    .map(|s| s.heads.len())

                    .unwrap_or(0);

                println!(

                    "    {} {}{}{}",

                    ui::dim(ui::glyph("↳", "->")),

                    ui::id(format!("{name}/{bm}")),

                    ui::sep(),

                    ui::dim(plural(heads, "head"))

                );

            }

        }

    }

    Ok(0)

}

/// The remote named, else `origin`, else the only remote there is.

fn remote_name(repo: &oxy_core::repo::Repo, remote: Option<&str>) -> String {

    remote.map_or_else(|| repo.default_remote(), str::to_string)

}

pub fn fetch(remote: Option<&str>, as_json: bool) -> Result<i32> {

    let repo = open()?;

    let remote = remote_name(&repo, remote);

    let sp = ui::spinner(&format!("Fetching from {remote}…"));

    let report = repo.fetch(&remote)?;

    sp.clear();

    if as_json {

        println!(

            "{}",

            json::obj([

                ("remote", json::s(&remote)),

                (

                    "refs",

                    json::arr(report.refs.iter().map(|(name, heads, n)| {

                        let t = repo.tracking(&remote, name).ok().flatten();

                        json::obj([

                            ("name", json::s(name)),

                            ("heads", json::hashes(heads)),

                            ("new", json::n(*n)),

                            (

                                "ahead",

                                t.map_or_else(|| "null".into(), |(a, _)| json::n(a)),

                            ),

                            (

                                "behind",

                                t.map_or_else(|| "null".into(), |(_, b)| json::n(b)),

                            ),

                        ])

                    }))

                ),

                ("new_tags", json::n(report.new_tags)),

                ("unverified", json::b(report.unverified)),

            ])

        );

        return Ok(0);

    }

    if report.refs.is_empty() {

        println!(

            "{} {}",

            ui::done("Fetched"),

            ui::dim(format!("nothing new from {remote}"))

        );

    }

    for (name, heads, n) in &report.refs {

        // What was fetched, then how the local bookmark stands against it:

        // "up to date" only when the two are the same (oxygen#56).

        let fetched =

            (*n > 0).then(|| format!("{}{}", ui::ok(plural(*n, "new change")), ui::sep()));

        let them = |k: usize| if k == 1 { "it" } else { "them" };

        let standing = match repo.tracking(&remote, name).ok().flatten() {

            None => ui::dim(format!("no local bookmark {name}")),

            Some((0, 0)) => ui::dim(format!("{name} up to date")),

            Some((0, b)) if *name == repo.config.bookmark => ui::warn(format!(

                "{name} is {} behind: oxy pull to take {}",

                plural(b, "change"),

                them(b)

            )),

            Some((0, b)) => ui::warn(format!(

                "{name} is {} behind: oxy bookmark switch {name} then oxy pull to take {}",

                plural(b, "change"),

                them(b)

            )),

            Some((a, 0)) => ui::dim(format!(

                "{name} is {} ahead: oxy push to send {}",

                plural(a, "change"),

                them(a)

            )),

            Some((a, b)) => ui::warn(format!(

                "{name} and {remote}/{name} have diverged ({a} here, {b} there): oxy pull to merge them"

            )),

        };

        let what = format!("{}{standing}", fetched.unwrap_or_default());

        println!(

            "{} {}{}{}{}{what}",

            ui::done("Fetched"),

            ui::id(format!("{remote}/{name}")),

            ui::sep(),

            ui::dim(plural(heads.len(), "head")),

            ui::sep()

        );

    }

    if report.new_tags > 0 {

        println!(

            "  {} {}",

            ui::note(),

            ui::dim(format!("{} adopted", plural(report.new_tags, "tag")))

        );

    }

    if report.unverified {

        eprintln!(

            "{} {remote} has no trust policy; nothing fetched from it was verified",

            ui::caution()

        );

    }

    Ok(0)

}

/// Pull acts on the current bookmark only: name the others the fetch

/// found behind their remote, which is easy to take for the current one

/// (oxygen#29).

fn others_behind(repo: &oxy_core::repo::Repo, remote: &str) {

    let Ok(bookmarks) = repo.bookmarks() else {

        return;

    };

    for b in bookmarks {

        let Some(n) = b.behind.filter(|n| *n > 0) else {

            continue;

        };

        if b.current {

            continue;

        }

        println!(

            "  {} {}",

            ui::note(),

            ui::dim(format!(

                "{} is {} behind {remote}/{}: oxy bookmark switch {} then oxy pull to take {}",

                b.name,

                plural(n, "change"),

                b.name,

                b.name,

                if n == 1 { "it" } else { "them" }

            ))

        );

    }

}

pub fn pull(remote: Option<&str>, as_json: bool) -> Result<i32> {

    let repo = open()?;

    let remote = remote_name(&repo, remote);

    let sp = ui::spinner(&format!("Pulling from {remote}…"));

    let r = repo.pull(&remote)?;

    if as_json {

        sp.clear();

        let conflicted = repo

            .snapshot_status("oxy pull")?

            .base_snapshot

            .is_conflicted();

        println!(

            "{}",

            json::obj([

                ("remote", json::s(&remote)),

                ("bookmark", json::s(&repo.config.bookmark)),

                ("heads", json::hashes(&r.heads)),

                ("changed", json::b(r.changed)),

                ("checked_out", json::b(r.checked_out)),

                ("conflicted", json::b(conflicted)),

                ("others", json::arr(r.others.iter().map(|o| json::s(o))))

            ])

        );

        return Ok(0);

    }

    if !r.changed {

        sp.done(&format!(

            "{} {}",

            ui::ok(ui::glyph("✔", "*")),

            ui::dim(format!(

                "{} is up to date with {remote}.",

                repo.config.bookmark

            ))

        ));

        others_pulled(&r.others);

        others_behind(&repo, &remote);

        return Ok(0);

    }

    sp.done(&format!(

        "{} {} now has {}{}",

        ui::done("Pulled:"),

        ui::bookmark(&repo.config.bookmark),

        plural(r.heads.len(), "head"),

        ui::dim(if r.checked_out {

            "; working copy updated"

        } else {

            "; run oxy checkout to update the working copy"

        })

    ));

    let snap = repo.snapshot("oxy pull")?;

    if snap.base_snapshot.is_conflicted() {

        println!(

            "  {} {}",

            ui::caution(),

            ui::warn("the result has conflicts; see oxy status")

        );

    }

    others_pulled(&r.others);

    others_behind(&repo, &remote);

    subrepos_behind(&repo);

    super::workspace::where_now(&repo);

    Ok(0)

}

/// The other bookmarks a pull moved.

fn others_pulled(others: &[String]) {

    if others.is_empty() {

        return;

    }

    let shown: Vec<String> = others.iter().take(8).map(ui::bookmark).collect();

    let more = others.len().saturating_sub(8);

    println!(

        "  {} {}{}",

        ui::done("Also updated"),

        shown.join(", "),

        if more > 0 {

            ui::dim(format!(" and {more} more"))

        } else {

            String::new()

        }

    );

}

/// `oxy push [REMOTE] --delete NAME`.

pub fn push_delete(remote: Option<&str>, name: &str, as_json: bool) -> Result<i32> {

    let repo = open()?;

    let remote = remote_name(&repo, remote);

    let sp = ui::spinner(&format!("Deleting {remote}/{name}…"));

    let results = repo.push_delete(&remote, name)?;

    sp.clear();

    if as_json {

        println!(

            "{}",

            json::arr(results.iter().map(|r| {

                json::obj([

                    ("name", json::s(&r.name)),

                    ("ok", json::b(r.ok)),

                    ("reason", json::s(&r.reason)),

                    ("state", json::s("")),

                ])

            }))

        );

        return Ok(if results.iter().all(|r| r.ok) { 0 } else { 1 });

    }

    let mut code = 0;

    for r in results {

        if r.ok {

            println!(

                "{} {}",

                ui::done("Deleted"),

                ui::id(format!("{remote}/{}", r.name))

            );

        } else {

            println!(

                "{} {} {}{}{}",

                ui::err(ui::glyph("✖", "x")),

                ui::err("Rejected"),

                ui::id(format!("{remote}/{}", r.name)),

                ui::sep(),

                r.reason

            );

            code = 1;

        }

    }

    Ok(code)

}

pub fn push(

    remote: Option<&str>,

    force: bool,

    bookmark: Option<&str>,

    as_json: bool,

) -> Result<i32> {

    let repo = open()?;

    let remote = remote_name(&repo, remote);

    let sp = ui::spinner(&format!("Pushing to {remote}…"));

    let results = match bookmark {

        Some(b) => repo.push_bookmark(&remote, b, force)?,