//! `oxy artifact`: Cylinder's artifacts (docs/cylinder.md §4.1, step C1):
//! a directory packed into a tree of the repository's own chunks, named by
//! the BLAKE3 of its canonical encoding.

use super::json;
use super::open;
use super::ui;
use anyhow::Result;
use cylinder::{Kind, Spec};
use std::path::Path;

/// `KEY=VALUE` pairs, refused when one has no `=`.
fn pairs(list: &[String], what: &str) -> Result<std::collections::BTreeMap<String, String>> {
    list.iter()
        .map(|p| {
            p.split_once('=')
                .map(|(k, v)| (k.to_string(), v.to_string()))
                .ok_or_else(|| anyhow::anyhow!("{what} {p:?}: write it KEY=VALUE"))
        })
        .collect()
}

fn summary(k: &cylinder::Kept) -> String {
    let a = &k.artifact;
    let mut parts = vec![a.kind.as_str().to_string()];
    parts.extend(a.os.clone());
    parts.extend(a.arch.clone());
    format!(
        "{} {} {}",
        ui::hash(&k.name[..12]),
        parts.join(" "),
        ui::dim(format!("{} bytes", a.total_size))
    )
}

fn as_json(k: &cylinder::Kept, files: usize) -> String {
    let a = &k.artifact;
    let text = |v: &Option<String>| v.as_deref().map(json::s).unwrap_or_else(|| "null".into());
    let map = |m: &std::collections::BTreeMap<String, String>| {
        let inner: Vec<String> = m
            .iter()
            .map(|(k, v)| format!("{}:{}", json::s(k), json::s(v)))
            .collect();
        format!("{{{}}}", inner.join(","))
    };
    json::obj([
        ("name", json::s(&k.name)),
        ("kind", json::s(a.kind.as_str())),
        ("arch", text(&a.arch)),
        ("os", text(&a.os)),
        ("tree", json::s(&a.tree.to_hex())),
        ("files", json::n(files as u64)),
        ("total_size", json::n(a.total_size)),
        ("env", map(&a.env)),
        ("labels", map(&a.labels)),
    ])
}

#[allow(clippy::too_many_arguments)]
pub fn pack(
    dir: &Path,
    kind: &str,
    arch: Option<String>,
    os: Option<String>,
    entrypoint: Vec<String>,
    env: &[String],
    labels: &[String],
    as_json_out: bool,
) -> Result<i32> {
    let repo = open()?;
    let mut spec = Spec::new(Kind::parse(kind)?);
    spec.arch = arch;
    spec.os = os;
    spec.entrypoint = (!entrypoint.is_empty()).then_some(entrypoint);
    spec.env = pairs(env, "env")?;
    spec.labels = pairs(labels, "label")?;
    let sp = ui::spinner("Packing…");
    let k = cylinder::pack(&repo, dir, &spec)?;
    sp.clear();
    let files = cylinder::tree(&repo, &k.artifact)?.entries.len();
    if as_json_out {
        println!("{}", as_json(&k, files));
    } else {
        println!(
            "{} {} as {}",
            ui::done("Packed"),
            ui::path(dir.display()),
            summary(&k)
        );
        println!("{}", ui::kv("name", &k.name));
        println!("{}", ui::kv("files", files.to_string()));
    }
    Ok(0)
}

pub fn list(as_json_out: bool) -> Result<i32> {
    let repo = open()?;
    let names = cylinder::list(&repo)?;
    let kept: Vec<cylinder::Kept> = names
        .iter()
        .map(|n| cylinder::open(&repo, n))
        .collect::<std::result::Result<_, _>>()?;
    if as_json_out {
        let items: Vec<String> = kept
            .iter()
            .map(|k| {
                let files = cylinder::tree(&repo, &k.artifact)
                    .map(|t| t.entries.len())
                    .unwrap_or(0);
                as_json(k, files)
            })
            .collect();
        println!("[{}]", items.join(","));
        return Ok(0);
    }
    if kept.is_empty() {
        println!("No artifacts yet: oxy artifact pack DIR --kind archive");
    }
    for k in &kept {
        println!("{}", summary(k));
    }
    Ok(0)
}

pub fn show(name: &str, as_json_out: bool) -> Result<i32> {
    let repo = open()?;
    let k = cylinder::open(&repo, name)?;
    let t = cylinder::tree(&repo, &k.artifact)?;
    if as_json_out {
        println!("{}", as_json(&k, t.entries.len()));
        return Ok(0);
    }
    println!("{}", summary(&k));
    println!("{}", ui::kv("name", &k.name));
    if let Some(e) = &k.artifact.entrypoint {
        println!("{}", ui::kv("entrypoint", e.join(" ")));
    }
    for (key, v) in &k.artifact.labels {
        println!("{}", ui::kv("label", format!("{key}={v}")));
    }
    for (key, v) in &k.artifact.env {
        println!("{}", ui::kv("env", format!("{key}={v}")));
    }
    for e in &t.entries {
        let mode = match e.mode {
            cylinder::MODE_EXEC => "x",
            cylinder::MODE_LINK => "l",
            _ => " ",
        };
        println!("  {mode} {:>10}  {}", e.size, e.path);
    }
    Ok(0)
}

pub fn unpack(name: &str, dest: &Path) -> Result<i32> {
    let repo = open()?;
    let k = cylinder::open(&repo, name)?;
    let n = cylinder::unpack(&repo, &k, dest)?;
    println!(
        "{} {} files of {} into {}",
        ui::done("Unpacked"),
        n,
        ui::hash(&k.name[..12]),
        ui::path(dest.display())
    );
    Ok(0)
}

pub fn verify(name: &str) -> Result<i32> {
    let repo = open()?;
    let k = cylinder::open(&repo, name)?;
    let n = cylinder::verify(&repo, &k)?;
    println!(
        "{} {}: its name, tree and {} files check out",
        ui::done("Verified"),
        ui::hash(&k.name[..12]),
        n
    );
    Ok(0)
}