//! 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>,

) -> 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")

        ))

    ));

    Ok(0)

}

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

    let mut repo = open()?;

    repo.config.set(&format!("remote.{name}.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)

}

fn remote_name(remote: Option<&str>) -> String {

    remote.unwrap_or("origin").to_string()

}

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

    let repo = open()?;

    let remote = remote_name(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)| json::obj([

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

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

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

                    ])))

                ),

                ("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 {

        let what = if *n == 0 {

            ui::dim("up to date")

        } else {

            ui::ok(plural(*n, "new change"))

        };

        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(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))

            ])

        );

        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_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_behind(&repo, &remote);

    Ok(0)

}

/// `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(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(remote);

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

    let results = match bookmark {

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

        None => repo.push(&remote, force)?,

    };

    sp.clear();

    if as_json {

        // The state each accepted bookmark now holds on the remote (its local

        // state object), so a caller can look up what the push started, such

        // as the checks a forge runs on it.

        let view = repo.view()?;

        println!(

            "{}",

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

                let state = view

                    .bookmarks

                    .get(&r.name)

                    .filter(|_| r.ok)

                    .map(|st| st.to_hex())

                    .unwrap_or_default();

                json::obj([

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

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

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

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

                ])

            }))

        );

        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("Pushed"),

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

                ui::sep(),

                ui::dim(if r.reason.is_empty() {

                    "updated"

                } else {

                    r.reason.as_str()

                })

            );

        } 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 serve(

    root: PathBuf,

    bind: &str,

    tokens: Vec<String>,

    tls: Option<(PathBuf, PathBuf)>,

) -> Result<i32> {

    let listener = std::net::TcpListener::bind(bind).with_context(|| format!("binding {bind}"))?;

    let root = root.canonicalize()?;

    let tls = tls.map(|(cert, key)| oxy_server::TlsFiles { cert, key });

    println!(

        "Serving repositories under {} on {}://{bind}/<repo>/oxy/v1/ ({})",

        root.display(),

        if tls.is_some() { "https" } else { "http" },

        if tokens.is_empty() {

            "open: no push tokens configured"

        } else {

            "push requires a token"

        }

    );

    if tls.is_none()

        && !bind.starts_with("127.")

        && !bind.starts_with("localhost")

        && !bind.starts_with("[::1]")

    {

        eprintln!("warning: serving plain HTTP on a non-loopback address; put a TLS terminator in front or pass --tls-cert/--tls-key");

    }

    oxy_server::run_blocking(listener, oxy_server::ServerConfig { root, tokens, tls })?;

    Ok(0)

}

pub fn git_export(git_dir: &std::path::Path, branch: Option<&str>) -> Result<i32> {

    let repo = open()?;

    let sp = ui::spinner("Exporting to Git…");

    let r = match branch {

        Some(b) => repo.git_export_as(git_dir, b)?,