//! 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::json;

use oxy_core::repo::SignatureStatus;

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>, bare: bool) -> Result<i32> {

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

    let repo = if bare { Repo::init_bare(&path)? } else { Repo::init(&path)? };

    println!("{} {}oxy repository in {}", ui::done("Initialized"), if bare { "bare " } else { "" }, 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, hunks: &[usize]) -> Result<i32> {

    let repo = open()?;

    let mut deps = Vec::new();

    for d in depends_on {

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

    }

    let selection = if !hunks.is_empty() {

        oxy_core::repo::Selection::Hunks(hunks.to_vec())

    } else 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(as_json: bool) -> Result<i32> {

    let repo = open()?;

    if as_json {

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

        let v = match repo.bisect_status()? {

            None => "null".to_string(),

            Some(NeedMarks { good, bad }) => json::obj([("state", json::s("need-marks")), ("good", json::n(good)), ("bad", json::n(bad))]),

            Some(Testing { heads, remaining, steps_left }) => json::obj([("state", json::s("testing")), ("heads", json::hashes(&heads)), ("remaining", json::n(remaining)), ("steps_left", json::n(steps_left))]),

            Some(Found { culprit }) => json::obj([("state", json::s("found")), ("culprit", json::s(&culprit.to_hex()))]),

            Some(Inconclusive { candidates }) => json::obj([("state", json::s("inconclusive")), ("candidates", json::hashes(&candidates))]),

        };

        println!("{v}");

        return Ok(0);

    }

    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.

fn signature_json(repo: &Repo, h: &oxy_core::hash::ChangeHash) -> Result<String> {

    Ok(match repo.authenticate_change(h)? {

        SignatureStatus::Unsigned => json::obj([("status", json::s("unsigned"))]),

        SignatureStatus::Valid { key, name, email, sealed, revoked } => json::obj([

            ("status", json::s(if sealed { "sealed" } else { "signed" })),

            ("key", json::s(&key.to_hex())),

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

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

            ("revoked", json::b(revoked)),

        ]),

        SignatureStatus::Invalid(why) => json::obj([("status", json::s("invalid")), ("reason", json::s(&why))]),

    })

}

fn log_entry_json(repo: &Repo, e: &oxy_core::repo::LogEntry) -> Result<String> {

    let c = &e.change;

    Ok(json::obj([

        ("hash", json::s(&e.hash.to_hex())),

        ("change_id", json::s(&c.change_id.to_hex())),

        ("author", json::s(&author_name(repo, c))),

        ("author_key", json::s(&c.author.to_hex())),

        ("when_ms", json::n(c.hlc.wall_ms)),

        ("message", json::s(&c.message)),

        ("kind", json::s(&format!("{:?}", c.kind).to_lowercase())),

        ("deps", json::hashes(&c.deps)),

        ("head", json::b(e.is_head)),

        ("working_copy", json::b(e.is_working_copy)),

        ("signature", if e.is_working_copy { "null".into() } else { signature_json(repo, &e.hash)? }),

    ]))

}

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

    let repo = open()?;

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

    let conflicted = snap.base_snapshot.is_conflicted();

    let entries = match path {

        Some(p) => repo.log_for_path(p)?,

        None => repo.log()?,

    };

    if as_json {

        let shown = limit.unwrap_or(entries.len()).min(entries.len());

        let mut items = Vec::new();

        for e in entries.iter().take(shown) {

            items.push(log_entry_json(&repo, e)?);

        }

        println!("{}", json::obj([("bookmark", json::s(&repo.config.bookmark)), ("total", json::n(entries.len())), ("changes", json::arr(items))]));

        return Ok(0);

    }

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