//! `spectra admin`: the ledger's own checks (spec §9.5, §19).

use super::{ui, Ctx};
use anyhow::Result;
use spectra_core::ledger::Ledger;
use spectra_core::principals::Principals;

/// `spectra admin verify`: recompute the chain, check every checkpoint and
/// proof; exit 1 when anything is wrong.
pub async fn verify(ctx: &Ctx, json: bool) -> Result<i32> {
    let ledger = Ledger::open_read_only(&ctx.db()?).await?;
    let spin = if json { None } else { Some(ui::spinner("verifying the ledger")) };
    let v = ledger.verify(&mut Principals::default()).await?;
    if let Some(s) = spin {
        s.clear();
    }
    if json {
        println!("{}", serde_json::to_string(&v)?);
        return Ok(if v.clean() { 0 } else { 1 });
    }
    if v.clean() {
        println!("{} {}", ui::done("Verified"), ui::subject("the ledger"));
    } else {
        println!(
            "{} {} {}",
            ui::err(ui::glyph("✘", "x")),
            ui::err("The ledger does not verify:"),
            ui::err(format!("{} finding(s)", v.findings.len()))
        );
    }
    println!("{}", ui::kv("events", v.events));
    let last = v.last_checkpoint.map(|s| format!("last at #{s}")).unwrap_or_else(|| "none yet".into());
    println!("{}", ui::kv("signed", format!("{} checkpoint(s){}{last}", v.checkpoints, ui::sep())));
    if v.uncovered > 0 {
        println!("{}", ui::kv("pending", ui::dim(format!("{} event(s) since, chained and awaiting the next checkpoint", v.uncovered))));
    }
    println!("{}", ui::kv("head", ui::hash(hex::encode(v.head))));
    for f in &v.findings {
        println!("  {} {} {}", ui::id(format!("#{}", f.seq)), ui::err(format!("{:?}", f.problem)), f.detail);
    }
    Ok(if v.clean() { 0 } else { 1 })
}

/// `spectra admin check`: do the projections equal a rebuild?
pub async fn check(ctx: &Ctx) -> Result<i32> {
    let ledger = ctx.writer().await?;
    let differ = ledger.check().await?;
    if differ.is_empty() {
        println!("{} {}", ui::done("Checked"), ui::subject("every projection matches the ledger"));
        Ok(0)
    } else {
        println!("{} projections differ from the ledger: {}", ui::caution(), ui::err(differ.join(", ")));
        println!("  {} {}", ui::note(), ui::dim("rebuild them with spectra admin rebuild"));
        Ok(1)
    }
}

/// `spectra admin rebuild`: replay the ledger into every projection.
pub async fn rebuild(ctx: &Ctx) -> Result<i32> {
    let ledger = ctx.writer().await?;
    let spin = ui::spinner("replaying the ledger");
    ledger.rebuild().await?;
    spin.done(&format!("{} {}", ui::done("Rebuilt"), ui::subject(format!("projections from {} events", ledger.head().await.0))));
    Ok(0)
}