//! 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], paths: &[String], interactive: bool) -> Result<i32> {

    let repo = open()?;

    let mut deps = Vec::new();

    for d in depends_on {

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

    }

    let selection = if interactive {

        let (_, hunks) = repo.hunks()?;

        if hunks.is_empty() {

            anyhow::bail!("nothing to commit: the working copy matches its base");

        }

        let hunks: Vec<_> = hunks.into_iter().filter(|h| paths.is_empty() || paths.iter().any(|p| h.path == *p || h.path.starts_with(&format!("{}/", p.trim_end_matches('/'))))).collect();

        let mut chosen = Vec::new();

        let stdin = std::io::stdin();

        let mut take_rest = false;

        for (n, h) in hunks.iter().enumerate() {

            if take_rest {

                chosen.push(h.index);

                continue;

            }

            println!("{} {} {}", ui::section(format!("hunk {} of {}", n + 1, hunks.len())), ui::path(&h.path), ui::dim(format!("(#{})", h.index)));

            for line in h.text.lines() {

                let styled = if line.starts_with('+') { ui::ok(line) } else if line.starts_with('-') { ui::err(line) } else { ui::dim(line) };

                println!("  {styled}");

            }

            loop {

                print!("{} ", ui::warn("Commit this hunk? [y]es [n]o [a]ll remaining [q]uit:"));

                use std::io::Write as _;

                std::io::stdout().flush()?;

                let mut answer = String::new();

                if stdin.read_line(&mut answer)? == 0 {

                    anyhow::bail!("aborted");

                }

                match answer.trim() {

                    "y" | "Y" => {

                        chosen.push(h.index);

                        break;

                    }

                    "n" | "N" | "" => break,

                    "a" | "A" => {

                        chosen.push(h.index);

                        take_rest = true;

                        break;

                    }

                    "q" | "Q" => anyhow::bail!("aborted; nothing committed"),

                    _ => continue,

                }

            }

        }

        if chosen.is_empty() {

            anyhow::bail!("no hunks chosen; nothing committed");

        }

        oxy_core::repo::Selection::Hunks(chosen)

    } else if paths.is_empty() {

        oxy_core::repo::Selection::All

    } else {

        oxy_core::repo::Selection::Paths(paths.to_vec())

    };

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

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

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

    if !matches!(selection, oxy_core::repo::Selection::All) {

        let rest = repo.snapshot("oxy commit")?;

        if !rest.statuses.is_empty() {

            println!("  {} {}", ui::note(), ui::dim(format!("{} left uncommitted", plural(rest.statuses.len(), "path"))));

        }

    }

    Ok(0)

}

pub fn blame(path: &str, json: bool) -> Result<i32> {

    let repo = open()?;

    let lines = repo.blame(path)?;

    if json {

        let items = lines.iter().map(|l| {

            format!(

                "{{\"line\":{},\"change_id\":{},\"hash\":{},\"index\":{},\"author\":{},\"when_ms\":{}}}",

                l.line,

                oxy_core::repo::json_str(&l.change_id.to_hex()),

                oxy_core::repo::json_str(&l.hash.to_hex()),

                l.index,

                oxy_core::repo::json_str(&l.author),

                l.when_ms

            )

        });

        println!("{}", oxy_core::repo::json_array(items));

        return Ok(0);

    }

    let width = lines.iter().map(|l| l.author.chars().count()).max().unwrap_or(0).min(20);

    let digits = lines.len().to_string().len();

    for l in &lines {

        let author: String = l.author.chars().take(20).collect();

        let text = String::from_utf8_lossy(&l.text);

        println!(

            "{} {} {} {:>digits$}{} {}",

            ui::id(l.change_id.short(8)),

            ui::author(format!("{author:<width$}")),

            ui::dim(ui::ago(l.when_ms)),

            l.line,

            ui::dim(ui::glyph("│", "|")),

            text.trim_end_matches('\n')

        );

    }

    Ok(0)

}

fn bisect_report(repo: &Repo, step: &oxy_core::repo::BisectStep) -> Result<i32> {

    use oxy_core::repo::BisectStep::*;

    match step {

        NeedMarks { good, bad } => {

            println!("{} {} {}", ui::note(), ui::dim(format!("{good} good, {bad} bad;")), ui::dim(if *good == 0 { "mark a known-good change or bookmark: oxy bisect good CHANGE" } else { "mark a known-bad change or bookmark: oxy bisect bad CHANGE" }));

            Ok(0)

        }

        Testing { heads, remaining, steps_left } => {

            println!("{} {} {}", ui::done("Testing"), ui::dim(format!("{} in the state under test;", plural(heads.len(), "head"))), ui::dim(format!("{remaining} candidates left, about {steps_left} more steps")));

            println!("  {} {}", ui::note(), ui::dim("run your test, then oxy bisect good | bad | skip"));

            Ok(0)

        }

        Found { culprit } => {

            let c = repo.store().get_change(culprit)?;

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

            println!("  {} {}", ui::note(), ui::dim("the first change whose inclusion makes the state bad; oxy bisect reset to return"));

            Ok(0)

        }

        Inconclusive { candidates } => {

            println!("{} {}", ui::caution(), ui::warn(format!("every remaining candidate was skipped ({}); oxy bisect reset to return", plural(candidates.len(), "change"))));

            Ok(1)

        }

    }

}

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

    let repo = open()?;

    repo.bisect_start()?;

    println!("{} bisect; {}", ui::done("Started"), ui::dim("now: oxy bisect good CHANGE and oxy bisect bad CHANGE"));

    Ok(0)

}

pub fn bisect_mark(good: Option<bool>, changes: &[String]) -> Result<i32> {

    let repo = open()?;

    let mut heads = Vec::new();

    for c in changes {

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

    }

    let step = repo.bisect_mark(good, &heads)?;

    bisect_report(&repo, &step)

}

pub fn bisect_run(command: &[String]) -> Result<i32> {

    let repo = open()?;

    let step = repo.bisect_run(command)?;

    bisect_report(&repo, &step)

}

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

    let repo = open()?;

    match repo.bisect_status()? {

        None => {

            println!("{}", ui::dim("No bisect in progress."));

            Ok(0)

        }

        Some(step) => bisect_report(&repo, &step),

    }

}

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

    let repo = open()?;

    repo.bisect_reset()?;

    println!("{} bisect; working copy restored", ui::done("Reset"));

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

    for n in &r.notes {

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

    }

    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;