//! Commands that act on the local repository and working copy.

use super::format::{author_name, deps_line, deps_of, plural, short_id, short_meta_id, signature_line, signature_mark, subject_of, when};

use super::open;

use super::ui;

use anyhow::Result;

use oxy_core::objects::ChangeKind;

use oxy_core::repo::{render_change, ChangeStatus, Repo};

use std::path::PathBuf;

pub fn init(path: Option<PathBuf>) -> Result<i32> {

    let path = path.unwrap_or(std::env::current_dir()?);

    let repo = Repo::init(&path)?;

    println!("{} oxy repository in {}", ui::done("Initialized"), ui::path(repo.root().display()));

    println!("{}", ui::kv("bookmark", ui::bookmark(&repo.config.bookmark)));

    println!("{}", ui::kv("author", format!("{} <{}>", ui::author(&repo.config.author_name), repo.config.author_email)));

    Ok(0)

}

fn status_tag(s: ChangeStatus) -> &'static str {

    match s {

        ChangeStatus::Added => "A",

        ChangeStatus::Modified => "M",

        ChangeStatus::Removed => "D",

        ChangeStatus::Renamed => "R",

        ChangeStatus::ModeChanged => "X",

        ChangeStatus::ConflictEdited => "C!",

        ChangeStatus::Resolved => "V",

    }

}

pub fn status(json: bool) -> Result<i32> {

    let repo = open()?;

    let sp = ui::spinner("Snapshotting the working copy…");

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

    let heads = repo.bookmark_heads()?;

    sp.clear();

    if json {

        println!("{}", repo.status_json(&snap)?);

        return Ok(if snap.base_snapshot.is_conflicted() { 2 } else { 0 });

    }

    println!(

        "{} {}{}working copy {}{}{}",

        ui::dim("On"),

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

        ui::sep(),

        ui::id(snap.wc.change_id.short(8)),

        ui::sep(),

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

    );

    if snap.statuses.is_empty() {

        println!("  {} {}", ui::ok(ui::glyph("✔", "*")), ui::dim("nothing to commit, working copy clean"));

    } else {

        println!();

        for s in &snap.statuses {

            println!("  {} {}", ui::status_mark(status_tag(s.status)), ui::path(&s.path));

        }

    }

    if !snap.base_snapshot.is_conflicted() {

        return Ok(0);

    }

    println!();

    println!("{} {}", ui::section(ui::err("Conflicts")), ui::dim("edit the marked files, or the .oxy-conflict-N candidates, then commit"));

    for c in &snap.base_snapshot.tree.conflicts {

        println!("  {} tree: {c:?}", ui::err(ui::glyph("✱", "!")));

    }

    for (p, f) in &snap.base_snapshot.files {

        if f.is_conflicted() {

            let state = match snap.statuses.iter().find(|s| s.path == *p).map(|s| s.status) {

                Some(ChangeStatus::Resolved) => ui::ok(format!("{} resolved in working copy", ui::glyph("✔", "*"))),

                Some(ChangeStatus::ConflictEdited) => ui::warn(format!("{} markers remain", ui::glyph("‼", "!"))),

                _ => ui::err(format!("{} unresolved", ui::glyph("✱", "!"))),

            };

            println!("  {}  {state}", ui::path(p));

        }

    }

    Ok(2)

}

pub fn commit(message: &str, depends_on: &[String]) -> Result<i32> {

    let repo = open()?;

    let mut deps = Vec::new();

    for d in depends_on {

        deps.push(repo.resolve_change(d)?);

    }

    let sp = ui::spinner("Committing…");

    let h = repo.commit(message, &deps)?;

    let c = repo.store().get_change(&h)?;

    sp.done(&format!("{} {} {}  {}", ui::done("Committed"), ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))), ui::subject(subject_of(message))));

    Ok(0)

}

/// The log: one entry per change, newest first, joined by a rail. The

/// default view is the subject and a metadata line; `verbose` adds the full

/// message, dependencies, and the authenticating key.

pub fn log(limit: Option<usize>, verbose: bool) -> Result<i32> {

    let repo = open()?;

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

    let conflicted = snap.base_snapshot.is_conflicted();

    let entries = repo.log()?;

    let total = entries.len();

    let shown = limit.unwrap_or(total).min(total);

    let rail = ui::rail();

    for (i, e) in entries.iter().take(shown).enumerate() {

        let c = &e.change;

        let bullet = ui::log_bullet(e.is_working_copy, e.is_head, e.is_working_copy && conflicted);

        let mut labels = Vec::new();

        if e.is_working_copy {

            labels.push(ui::warn("working copy"));

        }

        if c.kind == ChangeKind::Resolution {

            labels.push(ui::warn("resolution"));

        }

        let labels = if labels.is_empty() { String::new() } else { format!(" {}{}{}", ui::dim("("), labels.join(ui::dim(", ").as_str()), ui::dim(")")) };

        let subject = if e.is_working_copy && c.message.is_empty() {

            ui::dim(if snap.statuses.is_empty() { "(clean)" } else { "(uncommitted changes)" })

        } else {

            ui::subject(subject_of(&c.message))

        };

        println!("{bullet} {}{labels}  {subject}", ui::id(short_meta_id(c)));

        let meta = format!(

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

            ui::hash(format!("#{}", e.hash.short(12))),

            ui::sep(),

            ui::author(author_name(&repo, c)),

            ui::sep(),

            ui::dim(ui::ago(c.hlc.wall_ms)),

            ui::sep(),

            if e.is_working_copy { ui::dim("not yet committed") } else { signature_mark(&repo, &e.hash)? }

        );

        println!("{rail} {meta}");

        if verbose {

            if !e.is_working_copy {

                println!("{rail} {}", ui::dim(format!("{} {}", when(c.hlc.wall_ms), signature_line(&repo, &e.hash)?)));

            }

            if !c.deps.is_empty() {

                println!("{rail} {} {}", ui::dim(ui::glyph("↳", "->")), ui::dim(deps_of(&c.deps)));

            }

            let body: Vec<&str> = c.message.lines().skip(1).skip_while(|l| l.trim().is_empty()).collect();

            if !body.is_empty() {

                println!("{rail}");

                for line in body {

                    println!("{rail}   {line}");

                }

            }

        }

        if i + 1 < shown {

            println!("{rail}");

        }

    }

    if shown < total {

        println!("{}", ui::dim(format!("{} {} more; pass -n to see them", ui::glyph("…", "..."), total - shown)));

    }

    Ok(0)

}

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

    let repo = open()?;

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

    print!("{}", render_change(&snap.wc, &snap.base, &snap.base_snapshot));

    Ok(0)

}

pub fn show(change: &str) -> Result<i32> {

    let repo = open()?;

    repo.snapshot("oxy show")?;

    let h = repo.resolve_change(change)?;

    let c = repo.store().get_change(&h)?;

    println!("{} {} {}", ui::section("change"), ui::id(short_id(&c)), ui::hash(format!("#{h}")));

    println!("{}", ui::kv("kind", format!("{:?}", c.kind).to_lowercase()));

    println!("{}", ui::kv("author", ui::author(author_name(&repo, &oxy_core::state::ChangeMeta::of(&c)))));

    println!("{}", ui::kv("date", format!("{} {}", when(c.hlc.wall_ms), ui::dim(format!("({})", ui::ago(c.hlc.wall_ms))))));

    println!("{}", ui::kv("deps", ui::dim(deps_line(&c))));

    println!("{}", ui::kv("sig", signature_line(&repo, &h)?));

    println!();

    for line in (if c.message.is_empty() { "(no description)" } else { &c.message }).lines() {

        println!("    {line}");

    }

    println!();

    print!("{}", repo.describe_change(&h)?);

    Ok(0)

}

pub fn checkout(changes: &[String], discard: bool) -> Result<i32> {

    let repo = open()?;

    let heads = if changes.is_empty() {

        repo.bookmark_heads()?

    } else {

        let mut heads = Vec::new();

        for c in changes {

            heads.extend(repo.resolve_heads(c)?);

        }

        heads

    };

    let spec = if changes.is_empty() { repo.config.bookmark.clone() } else { changes.join(" ") };

    let sp = ui::spinner(&format!("Checking out {spec}…"));

    let r = repo.checkout(&heads, discard, &format!("oxy checkout {spec}"))?;

    sp.done(&format!("{} on {}: {} written, {} removed", ui::done("Working copy"), ui::bookmark(&spec), plural(r.written, "file"), r.removed));

    if r.conflicted {

        println!("  {} {}", ui::caution(), ui::warn("this state has conflicts; see oxy status"));

    }

    Ok(0)

}

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

    let repo = open()?;

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

    if !snap.base_snapshot.is_conflicted() {

        println!("The working copy's base has no conflicts.");

        return Ok(0);

    }

    let mut remaining = 0;

    for (p, f) in &snap.base_snapshot.files {

        if !f.is_conflicted() {

            continue;

        }

        match snap.statuses.iter().find(|s| s.path == *p).map(|s| s.status) {

            Some(ChangeStatus::Resolved) => println!("resolved   {p}"),

            Some(ChangeStatus::ConflictEdited) => {

                remaining += 1;

                println!("markers    {p}");

            }

            _ => {

                remaining += 1;

                println!("unresolved {p}");

            }

        }

    }

    for c in &snap.base_snapshot.tree.conflicts {

        remaining += 1;

        println!("tree       {c:?}");

    }

    if remaining == 0 {

        println!("All conflicts are resolved; `oxy commit` will record the resolution.");

        Ok(0)

    } else {

        Ok(2)

    }

}

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

    let repo = open()?;

    let op = repo.undo()?;

    println!("{} now at: {}", ui::done("Undone;"), ui::dim(&op.command));

    Ok(0)

}

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

    let repo = open()?;

    for (i, (r, op)) in repo.op_log()?.into_iter().enumerate() {

        let bullet = if i == 0 { ui::ok(ui::glyph("●", "@")) } else { ui::dim(ui::glyph("○", "o")) };

        let cmd = subject_of(&op.command).split("\\n").next().unwrap_or("");

        println!("{bullet} {}{}{}  {}", ui::hash(r.short(12)), ui::sep(), ui::dim(format!("{:<16}", ui::ago(op.hlc.wall_ms))), if i == 0 { ui::subject(cmd) } else { cmd.to_string() });

    }

    Ok(0)

}

pub fn gc(now: bool) -> Result<i32> {

    let repo = open()?;

    let sp = ui::spinner("Packing and pruning…");

    let r = repo.gc(now)?;

    sp.clear();

    if r.packed.objects > 0 {

        println!(

            "Packed {}: {} bytes -> {} bytes ({:.0}%).",

            plural(r.packed.objects, "loose object"),

            r.packed.raw_bytes,

            r.packed.packed_bytes,

            100.0 * r.packed.packed_bytes as f64 / r.packed.raw_bytes.max(1) as f64

        );

    }

    println!("{} reachable; pruned {} ({} bytes){}{}; {} present.",

        plural(r.reachable, "object"),

        plural(r.pruned.objects, "unreachable object"),

        r.pruned.bytes,

        if r.pruned.deferred > 0 { format!("; {} deferred by the grace period (use --now)", plural(r.pruned.deferred, "object")) } else { String::new() },

        if r.merged_packs > 0 { format!("; merged {} into one", plural(r.merged_packs, "pack")) } else { String::new() },

        plural(repo.store().pack_count(), "pack")

    );

    Ok(0)

}

/// The single head the working copy sits on, for commands that default to it.

fn current_head(repo: &Repo) -> Result<oxy_core::hash::ChangeHash> {

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

    let base = snap.base.maximal(&snap.wc.deps);

    match base.as_slice() {

        [h] => Ok(*h),

        _ => anyhow::bail!("the working copy sits on {} heads; name the change explicitly", base.len()),

    }

}

pub fn describe(message: &str, change: Option<&str>) -> Result<i32> {

    let repo = open()?;

    let h = match change {

        Some(c) => repo.resolve_change(c)?,

        None => current_head(&repo)?,

    };

    let new = repo.describe(&h, message)?;

    let c = repo.store().get_change(&new)?;

    println!("{} {} {}  {}", ui::done("Described"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), ui::subject(subject_of(message)));

    Ok(0)

}

pub fn amend(message: Option<&str>, into: Option<&str>) -> Result<i32> {

    let repo = open()?;

    let new = match into {

        Some(spec) => {

            let target = repo.resolve_change(spec)?;

            repo.amend_into(&target, message)?

        }

        None => repo.amend(message)?,

    };

    let c = repo.store().get_change(&new)?;

    println!("{} {} {}  {}", ui::done("Amended"), ui::id(short_id(&c)), ui::hash(format!("#{}", new.short(12))), ui::subject(subject_of(&c.message)));

    Ok(0)

}

pub fn abandon(change: &str) -> Result<i32> {

    let repo = open()?;

    let h = repo.resolve_change(change)?;

    let c = repo.store().get_change(&h)?;

    let notes = repo.abandon(&h)?;

    println!("{} {} {}  {}", ui::done("Abandoned"), ui::id(short_id(&c)), ui::hash(format!("#{}", h.short(12))), ui::dim("its content remains on disk as uncommitted work if the working copy sat on it"));

    for n in notes {

        println!("  {} {n}", ui::note());

    }

    Ok(0)

}

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

    let repo = open()?;

    let sp = ui::spinner("Writing checkpoint…");

    let (r, changes, bytes) = repo.checkpoint()?;

    sp.done(&format!("{} {} of {} ({} bytes) for {}", ui::done("Checkpoint"), ui::hash(format!("#{}", r.short(12))), plural(changes, "change"), bytes, ui::id(&repo.config.bookmark)));

    Ok(0)

}

/// For shell prompts: silent (exit 1) outside a repository, otherwise one line.

pub fn prompt(format: &str) -> Result<i32> {

    let Ok(repo) = Repo::open(&std::env::current_dir()?) else { return Ok(1) };

    let info = repo.quick_status()?;

    println!("{}", info.format(format));

    Ok(0)

}

pub fn sparse(paths: &[String]) -> Result<i32> {

    let mut repo = open()?;

    if paths.is_empty() {

        if repo.config.sparse_paths.is_empty() {

            println!("No sparse filter: the whole tree is materialized.");

        } else {

            println!("{}", ui::heading("Sparse filter"));

            for p in &repo.config.sparse_paths {

                println!("  {}", ui::path(p));

            }

        }

        return Ok(0);

    }

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

    if !snap.wc.tree_ops.is_empty() || !snap.wc.edits.is_empty() {

        anyhow::bail!("the working copy has changes; commit them before changing the sparse filter");

    }

    repo.config.set("filter.paths", &paths.join(","))?;

    repo.save_config()?;

    let heads = repo.bookmark_heads()?;

    let sp = ui::spinner("Re-checking out with the new filter…");

    let r = repo.checkout(&heads, true, "oxy sparse (checkout)")?;

    sp.done(&format!("{} {}: {} written, {} removed", ui::ok("Sparse filter set to"), ui::path(paths.join(",")), plural(r.written, "file"), r.removed));

    Ok(0)

}

pub fn tag_create(name: &str, changes: &[String], message: &str) -> Result<i32> {

    let repo = open()?;

    repo.snapshot("oxy tag")?;

    let heads = if changes.is_empty() {

        repo.bookmark_heads()?

    } else {

        let mut heads = Vec::new();

        for c in changes {

            heads.extend(repo.resolve_heads(c)?);

        }

        heads

    };

    let t = repo.tag_create(name, &heads, message)?;

    println!(

        "{} {} {} {} ({}){}",

        ui::done("Tagged"),

        ui::bookmark(&t.name),

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

        ui::hash(format!("#{}", t.state.short(12))),

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

        t.signer.map(|s| format!(", signed by {s}")).unwrap_or_else(|| ui::dim(", unsigned"))

    );

    Ok(0)

}

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

    let repo = open()?;

    let tags = repo.tags()?;

    if tags.is_empty() {

        println!("{}", ui::dim("No tags."));

    }

    for t in tags {

        println!(