//! Execution receipts (spec §14.6): list, show, verify and import the
//! signed receipts runners make.

use super::json;
use super::open;
use super::ui;
use anyhow::{bail, Result};
use oxy_core::receipt::SignedReceipt;
use oxy_core::repo::ReceiptInfo;

fn status(problem: Option<&str>, revoked: bool) -> String {
    match (problem, revoked) {
        (Some(p), _) => ui::err(format!("{} {p}", ui::glyph("✘", "x"))),
        (None, true) => ui::warn(format!("{} runner key revoked", ui::glyph("!", "!"))),
        (None, false) => ui::ok(format!("{} signed", ui::glyph("✔", "v"))),
    }
}

fn line(sr: &SignedReceipt, problem: Option<&str>, revoked: bool) -> String {
    let r = &sr.receipt;
    let result = if r.passed() {
        ui::ok(format!("{} passed", ui::glyph("●", "*")))
    } else {
        ui::err(format!("{} exit {}", ui::glyph("●", "*"), r.exit_code))
    };
    format!(
        "{} {}{}{}{}{}",
        result,
        ui::subject(&r.job_name),
        ui::sep() + &ui::dim(format!("{:.1} s", r.duration_ms as f64 / 1000.0)),
        ui::sep() + &ui::author(&sr.runner.name),
        ui::sep() + &status(problem, revoked),
        ui::sep() + &ui::dim(ui::ago(sr.attest.hlc.wall_ms)),
    )
}

fn to_json(
    attest: Option<String>,
    sr: &SignedReceipt,
    problem: Option<&str>,
    revoked: bool,
) -> String {
    let r = &sr.receipt;
    let refs = |v: &[oxy_core::hash::ObjectRef]| json::arr(v.iter().map(|h| json::s(&h.to_hex())));
    json::obj([
        ("attest", json::opt(attest.as_ref(), |a| json::s(a))),
        ("receipt", json::s(&r.hash().to_hex())),
        ("state", json::s(&sr.state().to_hex())),
        ("run", json::s(sr.run())),
        ("job", json::s(&r.job_name)),
        ("exit_code", json::n(r.exit_code)),
        ("duration_ms", json::n(r.duration_ms)),
        ("pipeline", json::s(&r.pipeline_hash.to_hex())),
        ("scope", json::s(&r.scope_tree_hash.to_hex())),
        ("environment", json::s(&r.environment.to_hex())),
        ("inputs", refs(&r.inputs)),
        ("outputs", refs(&r.outputs)),
        ("runner", json::s(&sr.runner.hash().to_hex())),
        ("runner_name", json::s(&sr.runner.name)),
        ("made_ms", json::n(sr.attest.hlc.wall_ms)),
        ("valid", json::b(problem.is_none())),
        ("problem", json::opt(problem, json::s)),
        ("revoked", json::b(revoked)),
    ])
}

fn detail(sr: &SignedReceipt, problem: Option<&str>, revoked: bool) {
    let r = &sr.receipt;
    println!("{}", line(sr, problem, revoked));
    println!(
        "{}",
        ui::kv("run", if sr.run().is_empty() { "-" } else { sr.run() })
    );
    println!(
        "{}",
        ui::kv("state", ui::hash(format!("#{}", sr.state().short(12))))
    );
    println!(
        "{}",
        ui::kv("receipt", ui::hash(format!("#{}", r.hash().short(12))))
    );
    println!(
        "{}",
        ui::kv("pipeline", ui::hash(r.pipeline_hash.short(12)))
    );
    println!("{}", ui::kv("scope", ui::hash(r.scope_tree_hash.short(12))));
    println!(
        "{}",
        ui::kv("environment", ui::hash(r.environment.short(12)))
    );
    println!(
        "{}",
        ui::kv(
            "runner",
            format!("{} {}", sr.runner.name, ui::dim(sr.runner.hash().short(12)))
        )
    );
    for (what, v) in [("input", &r.inputs), ("output", &r.outputs)] {
        for h in v.iter() {
            println!("{}", ui::kv(what, ui::hash(h.short(12))));
        }
    }
}

/// `oxy receipt list [REV]`: the receipts kept for a state.
pub fn list(rev: Option<&str>, as_json: bool) -> Result<i32> {
    let repo = open()?;
    let heads = match rev {
        Some(r) => repo.resolve_heads(r)?,
        None => repo.bookmark_heads()?,
    };
    let found = repo.receipts(&heads)?;
    if as_json {
        println!(
            "{}",
            json::arr(found.iter().map(|i| to_json(
                Some(i.attest.to_hex()),
                &i.signed,
                i.problem.as_deref(),
                i.revoked
            )))
        );
        return Ok(0);
    }
    if found.is_empty() {
        println!("{}", ui::dim("No receipts for this state."));
    }
    for i in &found {
        println!(
            "{} {}",
            ui::hash(format!("#{}", i.attest.short(12))),
            line(&i.signed, i.problem.as_deref(), i.revoked)
        );
    }
    Ok(0)
}

fn find(repo: &oxy_core::repo::Repo, prefix: &str, rev: Option<&str>) -> Result<ReceiptInfo> {
    let heads = match rev {
        Some(r) => repo.resolve_heads(r)?,
        None => repo.bookmark_heads()?,
    };
    let p = prefix.trim_start_matches('#').to_ascii_lowercase();
    let mut hits: Vec<ReceiptInfo> = repo
        .receipts(&heads)?
        .into_iter()
        .filter(|i| i.attest.to_hex().starts_with(&p))
        .collect();
    match hits.len() {
        1 => Ok(hits.remove(0)),
        0 => bail!("no receipt #{p} for this state; `oxy receipt list` shows them"),
        n => bail!("#{p} matches {n} receipts; give more of the hash"),
    }
}

/// `oxy receipt show HASH [--rev REV]`.
pub fn show(prefix: &str, rev: Option<&str>, as_json: bool) -> Result<i32> {
    let repo = open()?;
    let i = find(&repo, prefix, rev)?;
    if as_json {
        println!(
            "{}",
            to_json(
                Some(i.attest.to_hex()),
                &i.signed,
                i.problem.as_deref(),
                i.revoked
            )
        );
    } else {
        detail(&i.signed, i.problem.as_deref(), i.revoked);
    }
    Ok(if i.problem.is_some() { 1 } else { 0 })
}

/// `oxy receipt export HASH FILE`: the signed receipt, to hand to anyone.
pub fn export(prefix: &str, file: &str, rev: Option<&str>) -> Result<i32> {
    let repo = open()?;
    let i = find(&repo, prefix, rev)?;
    std::fs::write(file, i.signed.encode())?;
    println!(
        "{} {} {}",
        ui::done("Exported receipt"),
        ui::hash(format!("#{}", i.attest.short(12))),
        ui::path(file)
    );
    Ok(0)
}

fn read(file: &str) -> Result<SignedReceipt> {
    let bytes = std::fs::read(file).map_err(|e| anyhow::anyhow!("{file}: {e}"))?;
    SignedReceipt::decode(&bytes).map_err(|e| anyhow::anyhow!("{file}: not a signed receipt: {e}"))
}

/// `oxy receipt verify FILE`: check a signed receipt without keeping it.
pub fn verify(file: &str, as_json: bool) -> Result<i32> {
    let sr = read(file)?;
    let problem = sr.verify().err().map(|e| e.to_string());
    if as_json {
        println!("{}", to_json(None, &sr, problem.as_deref(), false));
    } else {
        detail(&sr, problem.as_deref(), false);
    }
    Ok(if problem.is_some() { 1 } else { 0 })
}

/// `oxy receipt import FILE`: verify a signed receipt and keep it.
pub fn import(file: &str) -> Result<i32> {
    let repo = open()?;
    let sr = read(file)?;
    let r = repo.add_receipt(&sr)?;
    println!(
        "{} {} {} {} {}",
        ui::done("Kept receipt"),
        ui::hash(format!("#{}", r.short(12))),
        ui::subject(&sr.receipt.job_name),
        ui::dim("by"),
        ui::author(&sr.runner.name)
    );
    Ok(0)
}