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

use super::{ui, Ctx};

use anyhow::{Context, 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 spin = if json { None } else { Some(ui::spinner("verifying the ledger")) };

    // On a client the server verifies its own ledger (spec §8.6).

    let v: serde_json::Value = match ctx.remote()? {

        Some(_) => {

            let home = super::identity::owner_home(ctx, None);

            let c = ctx.owner_client(&home).await?.context("no server")?;

            super::call(&c, "GET", "/api/v1/admin/verify", None).await?

        }

        None => serde_json::to_value(Ledger::open_read_only(&ctx.db()?).await?.verify(&mut Principals::default()).await?)?,

    };

    if let Some(s) = spin {

        s.clear();

    }

    let findings = v["findings"].as_array().cloned().unwrap_or_default();

    let clean = findings.is_empty();

    if json {

        println!("{v}");

        return Ok(if clean { 0 } else { 1 });

    }

    if 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)", findings.len()))

        );

    }

    println!("{}", ui::kv("events", v["events"].as_u64().unwrap_or(0)));

    let last = v["last_checkpoint"].as_u64().map(|s| format!("last at #{s}")).unwrap_or_else(|| "none yet".into());

    println!("{}", ui::kv("signed", format!("{} checkpoint(s){}{last}", v["checkpoints"].as_u64().unwrap_or(0), ui::sep())));

    let uncovered = v["uncovered"].as_u64().unwrap_or(0);

    if uncovered > 0 {

        println!("{}", ui::kv("pending", ui::dim(format!("{uncovered} event(s) since, chained and awaiting the next checkpoint"))));

    }

    println!("{}", ui::kv("head", ui::hash(v["head"].as_str().unwrap_or(""))));

    for f in &findings {

        // As the problem is named in code: hash_mismatch is HashMismatch.

        let problem = match &f["problem"] {

            serde_json::Value::String(p) => p

                .split('_')

                .map(|w| {

                    let mut c = w.chars();

                    c.next().map(|f| f.to_uppercase().chain(c).collect::<String>()).unwrap_or_default()

                })

                .collect(),

            other => other.to_string(),

        };

        println!(

            "  {} {} {}",

            ui::id(format!("#{}", f["seq"].as_u64().unwrap_or(0))),

            ui::err(problem),

            f["detail"].as_str().unwrap_or("")

        );

    }

    Ok(if clean { 0 } else { 1 })

}

/// `spectra admin check`: do the projections equal a rebuild?

pub async fn check(ctx: &Ctx) -> Result<i32> {

    ctx.local_only("spectra admin check")?;

    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> {

    ctx.local_only("spectra admin rebuild")?;

    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)

}