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

use super::format::plural;

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 {} ({} on {}: {})", ui::ok("Cloned"), ui::path(repo.root().display()), url, ui::id(&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!("Added remote {name} = {url}");

    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!("Removed remote {name}");

    Ok(0)

}

pub fn remote_list() -> Result<i32> {

    let repo = open()?;

    let view = repo.view()?;

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

        println!("{name}\t{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!("    {bm}: {}", plural(heads, "head"));

            }

        }

    }

    Ok(0)

}

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

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

}

pub fn fetch(remote: Option<&str>) -> 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();

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

        println!("{} {}, {}", ui::id(format!("{remote}/{name}")), plural(heads.len(), "head"), plural(*n, "new change"));

    }

    if report.unverified {

        eprintln!("{} {remote} has no trust policy; nothing fetched from it was verified", ui::warn("warning:"));

    }

    Ok(0)

}

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

    let repo = open()?;

    let remote = remote_name(remote);

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

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

    if !r.changed {

        sp.done(&ui::dim("Already up to date."));

        return Ok(0);

    }

    sp.done(&format!(

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

        ui::ok("Pulled:"),

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

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

        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::warn("the result has conflicts; see oxy status"));

    }

    Ok(0)

}

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

    let repo = open()?;

    let remote = remote_name(remote);

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

    let results = repo.push(&remote, force)?;

    sp.clear();

    let mut code = 0;

    for r in results {

        if r.ok {

            println!("{} {}", ui::id(format!("{remote}/{}", r.name)), ui::ok(if r.reason.is_empty() { "updated" } else { r.reason.as_str() }));

        } else {

            println!("{} {} {}", ui::id(format!("{remote}/{}", r.name)), ui::err("rejected:"), 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) -> Result<i32> {

    let repo = open()?;

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

    let r = repo.git_export(git_dir)?;

    sp.clear();

    println!(

        "Exported {} to {} (branch {}: {}{}); {} already exported.",

        plural(r.exported, "change"),

        git_dir.display(),

        r.branch,

        plural(r.heads, "head"),

        if r.heads > 1 { ", joined by a synthetic merge commit" } else { "" },

        r.skipped

    );

    Ok(0)

}

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

    let repo = Repo::init(dest)?;

    let started = std::time::Instant::now();

    let sp = ui::spinner(&format!("Importing {} {branch}…", git_dir.display()));

    let r = repo.import_git(git_dir, branch)?;

    sp.clear();

    println!(

        "Imported {} ({} merges) from {} {branch} into {} in {:.1?}: {} now has {}.{}",

        plural(r.commits, "commit"),

        r.merges,

        git_dir.display(),

        repo.root().display(),

        started.elapsed(),

        repo.config.bookmark,

        plural(r.heads, "head"),

        if r.skipped_submodules > 0 { format!(" Skipped {} submodule entries.", r.skipped_submodules) } else { String::new() }

    );

    Ok(0)

}

pub fn deepen(remote: &str, depth: u32) -> Result<i32> {

    let repo = open()?;

    if !repo.is_shallow() {

        println!("{}", ui::dim("This repository is not shallow; nothing to deepen."));

        return Ok(0);

    }

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

    let n = repo.deepen(remote, depth)?;

    sp.done(&format!("{} {}; {}", ui::ok("Deepened by"), plural(n, "change"), if repo.is_shallow() { "still shallow".to_string() } else { ui::ok("history is now complete") }));

    Ok(0)

}