//! El sandbox hermético de build (bubblewrap). Ver `docs/02-build-lab.md` §3 y §4.
//!
//! Capas:
//!   - Base read-only: rootfs Alpine (`.dev-fs/alpine`) montado como overlay con capa
//!     tmpfs encima, así el build puede escribir en /tmp/etc sin ensuciar el host.
//!   - Compilador inyectado: `zig` (`.dev-fs/tools/zig`) en `/opt/zig`.
//!   - Fuentes: bind RW en `/src` (deben venir ya copiadas a un dir host descartable).
//!   - Salida: bind RW en `/out` (DESTDIR).
//!   - Red: aislada (`--unshare-all` incluye `--unshare-net`).

use std::collections::VecDeque;
use std::io::{BufRead, BufReader, Write};
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::{Arc, Mutex};

/// Cuántas líneas finales del log del sandbox conservamos para `BuildFailed.log_tail`.
const TAIL_LINES: usize = 50;

/// Fallo de una fase de build, con la cola del log del lab si la pudimos capturar. Viaja
/// dentro de `hammer_core::Error::Other(anyhow)`; el bus la recupera por `downcast_ref` para
/// poblar `Event::BuildFailed.log_tail`. Ver `docs/07-agent-bus.md`.
#[derive(Debug, Clone)]
pub struct BuildFailure {
    pub reason: String,
    pub log_tail: Option<String>,
}

impl std::fmt::Display for BuildFailure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.reason)?;
        if let Some(tail) = &self.log_tail {
            write!(f, "\n--- log (últimas líneas) ---\n{tail}")?;
        }
        Ok(())
    }
}

impl std::error::Error for BuildFailure {}

impl BuildFailure {
    /// Recupera un `BuildFailure` de un error de hammer-core, si lo lleva dentro. El bus lo
    /// usa para separar `reason` de `log_tail`.
    pub fn from_error(e: &hammer_core::Error) -> Option<&BuildFailure> {
        match e {
            hammer_core::Error::Other(a) => a.downcast_ref::<BuildFailure>(),
            _ => None,
        }
    }
}

/// Empuja `line` a un ring buffer acotado a `cap` líneas (descarta la más antigua).
fn push_tail(buf: &mut VecDeque<String>, line: String, cap: usize) {
    if buf.len() == cap {
        buf.pop_front();
    }
    buf.push_back(line);
}

#[derive(Debug, Clone)]
pub struct Sandbox {
    pub rootfs: PathBuf,
    pub zig_dir: PathBuf,
    pub src_dir: PathBuf,
    pub out_dir: PathBuf,
    /// Si Some, se bindea RW como `/cache` y se setea `ZIG_GLOBAL_CACHE_DIR=/cache/zig`.
    /// Persistir esta caché entre builds evita que `zig cc` recompile musl cada vez (~30s).
    pub cache_dir: Option<PathBuf>,
    /// Directorios sellados de las `deps.build` (artefactos ya construidos en el store). Cada uno se
    /// apila como capa overlay read-only BAJO el rootfs Alpine, así sus `usr/{include,lib,lib/pkgconfig}`
    /// aparecen en las rutas estándar de `/usr` — el compilador y pkgconf los ven sin plumbing de flags.
    /// Vacío ⇒ ninguna capa extra ⇒ el sandbox es idéntico al de una receta sin deps (baseline intacto).
    pub deps: Vec<PathBuf>,
    /// Vars de entorno extra inyectadas además del set por defecto.
    pub env: Vec<(String, String)>,
}

impl Sandbox {
    /// Ejecuta `cmd` dentro del sandbox bajo `sh -c`. Hace *tee* de stdout/stderr al padre
    /// (para no perder el streaming en vivo) y a la vez retiene las últimas [`TAIL_LINES`]
    /// líneas; si el exit code es != 0, devuelve un [`BuildFailure`] con esa cola en
    /// `log_tail`, envuelto en `hammer_core::Error::Other`.
    pub fn run(&self, cmd: &str) -> hammer_core::Result<()> {
        let args = self.bwrap_args(cmd);
        tracing::debug!(?args, "bwrap");
        let mut child = Command::new("bwrap")
            .args(&args)
            .stdin(Stdio::null())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()
            .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("spawn bwrap: {e}")))?;

        // Ring buffer compartido por ambos pumps: la cola combinada de stdout+stderr.
        let tail = Arc::new(Mutex::new(VecDeque::<String>::with_capacity(TAIL_LINES)));
        let out = child.stdout.take().expect("stdout piped");
        let err = child.stderr.take().expect("stderr piped");
        let h_out = spawn_pump(out, tail.clone());
        let h_err = spawn_pump(err, tail.clone());

        let status = child
            .wait()
            .map_err(|e| hammer_core::Error::Other(anyhow::anyhow!("wait bwrap: {e}")))?;
        // Aseguramos drenar ambos streams antes de leer la cola.
        let _ = h_out.join();
        let _ = h_err.join();

        if !status.success() {
            let tail_str = {
                let g = tail.lock().expect("tail mutex");
                if g.is_empty() {
                    None
                } else {
                    Some(g.iter().cloned().collect::<Vec<_>>().join("\n"))
                }
            };
            let reason = format!(
                "build phase falló (exit {}): {cmd}",
                status.code().map(|c| c.to_string()).unwrap_or_else(|| "?".into())
            );
            return Err(hammer_core::Error::Other(anyhow::Error::new(BuildFailure {
                reason,
                log_tail: tail_str,
            })));
        }
        Ok(())
    }

    fn bwrap_args(&self, cmd: &str) -> Vec<String> {
        let mut args: Vec<String> = vec![
            "--overlay-src".into(),
            self.rootfs.display().to_string(),
        ];
        // Capas overlay de las deps de build, apiladas bajo el rootfs (mismo `--tmp-overlay /`). bwrap
        // admite múltiples `--overlay-src` para un overlay; los `usr/{include,lib}` de cada dep se
        // funden con los del rootfs en `/usr`. Sólo se emiten si hay deps (compat hacia atrás).
        for dep in &self.deps {
            args.push("--overlay-src".into());
            args.push(dep.display().to_string());
        }
        args.extend([
            "--tmp-overlay".into(),
            "/".into(),
            "--proc".into(),
            "/proc".into(),
            "--dev".into(),
            "/dev".into(),
            "--tmpfs".into(),
            "/tmp".into(),
            "--ro-bind".into(),
            self.zig_dir.display().to_string(),
            "/opt/zig".into(),
            "--bind".into(),
            self.src_dir.display().to_string(),
            "/src".into(),
            "--bind".into(),
            self.out_dir.display().to_string(),
            "/out".into(),
            "--chdir".into(),
            "/src".into(),
            "--unshare-all".into(),
            "--die-with-parent".into(),
        ]);

        if let Some(cache) = &self.cache_dir {
            args.push("--bind".into());
            args.push(cache.display().to_string());
            args.push("/cache".into());
        }

        // Entorno mínimo y predecible.
        let mut defaults: Vec<(&str, &str)> = vec![
            ("PATH", "/opt/zig:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"),
            ("HOME", "/tmp"),
            ("DESTDIR", "/out"),
            ("PREFIX", "/usr"),
            // `-mcpu=baseline`: codegen al baseline x86-64 genérico, NO al CPU del builder. Sin esto,
            // `zig cc` default a `-mcpu=native` y hornea la ISA de quien compila (SHA-NI/AVX2 del
            // host) ⇒ el binario diverge entre CPUs distintos (host vs la VM `-cpu Broadwell`) y
            // rompe la reproducibilidad — un no-determinismo que Stage 2 cazó (runbook §8c, SDD 09
            // §2). De paso cierra el SIGILL de AVX en qemu64 (runbook §7). Las rutas SIMD que sí
            // necesita el runtime (blake3/sha2) son asm con dispatch en runtime: siguen presentes.
            ("CC", "zig cc -mcpu=baseline"),
            ("CXX", "zig c++ -mcpu=baseline"),
            ("AR", "zig ar"),
            ("LC_ALL", "C"),
            ("LANG", "C"),
            // Reproducibilidad (pre-Stage 2): fija los timestamps que muchas herramientas embeben
            // (tar, ar, gzip, __DATE__/__TIME__ vía SOURCE_DATE_EPOCH). Valor fijo y arbitrario
            // (1970-01-01 00:00:01). Las rutas ya son deterministas: el source se bindea en `/src`
            // (constante entre rebuilds, sea cual sea el work dir del host). Ver SDD 11 / runbook.
            ("SOURCE_DATE_EPOCH", "1"),
            ("TZ", "UTC"),
            // Reproducibilidad de builds Cargo: fuerza `codegen-units = 1` para TODAS las crates
            // del build (el var de cargo gana sobre el `[profile.release]` del repo fuente). Con el
            // default (16) el codegen paralelo de rustc reparte el crate en N unidades y la salida
            // varía build-a-build incluso en la MISMA máquina y con entradas idénticas — Stage 2 lo
            // cazó: `arje-zero` (cuyo workspace tawasuyu no fija perfil) divergía ~10 KB repartidos
            // por .text/.rodata/.eh_frame, mientras `hammerd` (workspace hammer que SÍ pinea
            // codegen-units=1) reproducía bit-a-bit. El lab lo impone en vez de confiar en que cada
            // repo upstream lo declare (SDD 09 §2). Inerte para builds no-Cargo (musl/busybox lo
            // ignoran). Ver runbook §8c / SDD 11.
            ("CARGO_PROFILE_RELEASE_CODEGEN_UNITS", "1"),
            // Reproducibilidad de builds Cargo (parte 2): `codegen-units=1` NO basta. El backend
            // paralelo de rustc/LLVM (ThinLTO + codegen) lanza un pool de hilos dimensionado por la
            // paralelismo disponible, y sus decisiones (orden de import/inline) varían build-a-build
            // a >1 hilo ⇒ `arje-zero` divergía ~62 KB entre dos builds host idénticos, mientras un
            // build serial (la VM tiene 1 vCPU, o `taskset -c 0`) reproducía bit-a-bit. `JOBS=1`
            // limita el jobserver a 1 token ⇒ rustc serializa el backend ⇒ salida estable e
            // independiente del nº de CPUs del que reconstruye. Lo cazó Stage 2 variante (b): host
            // (paralelo) daba `0039b2b9…` no-reproducible vs VM (serial) `9adefb82…`. Ver SDD 09 §2.
            ("CARGO_BUILD_JOBS", "1"),
        ];
        if self.cache_dir.is_some() {
            defaults.push(("ZIG_GLOBAL_CACHE_DIR", "/cache/zig"));
            defaults.push(("ZIG_LOCAL_CACHE_DIR", "/cache/zig"));
        }
        for (k, v) in defaults {
            args.push("--setenv".into());
            args.push(k.into());
            args.push(v.into());
        }
        for (k, v) in &self.env {
            args.push("--setenv".into());
            args.push(k.clone());
            args.push(v.clone());
        }

        // Comando final.
        args.push("/bin/sh".into());
        args.push("-c".into());
        args.push(cmd.into());
        args
    }
}

/// Lanza un thread que lee `reader` línea a línea, la reenvía a stderr del padre y la
/// acumula en el ring `tail`. Devuelve el handle para join.
///
/// El tee va SIEMPRE a stderr (tanto el stdout como el stderr del build): stdout del proceso
/// queda reservado para el resultado legible-por-máquina (el content-hash que imprime la CLI,
/// p. ej. `bootstrap stage1`). Antes el stdout del build se teeaba al stdout del padre y se
/// colaba en capturas tipo `PRIME=$(hammer … bootstrap stage1)`; con builds reales (no cacheados,
/// p. ej. el rebuild in-VM) eso son miles de líneas de `configure`/`make` ⇒ el argumento crece y
/// la fase de verificación siguiente (`--rootfs "$PRIME"`) revienta el exec con E2BIG
/// (Argument list too long). Va a stderr, junto a los logs de tracing. Ver runbook §8c.
fn spawn_pump<R: std::io::Read + Send + 'static>(
    reader: R,
    tail: Arc<Mutex<VecDeque<String>>>,
) -> std::thread::JoinHandle<()> {
    std::thread::spawn(move || {
        let buf = BufReader::new(reader);
        for line in buf.lines() {
            let line = match line {
                Ok(l) => l,
                Err(_) => break,
            };
            // Tee en vivo al padre por stderr (sin bufferizar de más: el build puede tardar).
            let _ = writeln!(std::io::stderr(), "{line}");
            if let Ok(mut g) = tail.lock() {
                push_tail(&mut g, line, TAIL_LINES);
            }
        }
    })
}

/// Errores tempranos: comprueba que las rutas base existen antes de invocar el build.
pub fn ensure_layout(rootfs: &Path, zig_dir: &Path) -> hammer_core::Result<()> {
    // bin/sh en Alpine es un symlink absoluto a /bin/busybox, que desde el host no resuelve.
    // Comprobamos el archivo regular real para no engañarnos.
    if !rootfs.join("bin/busybox").is_file() {
        return Err(hammer_core::Error::Other(anyhow::anyhow!(
            "rootfs inválido: no encuentro {}/bin/busybox — ¿corriste el bootstrap de Alpine?",
            rootfs.display()
        )));
    }
    if !zig_dir.join("zig").exists() {
        return Err(hammer_core::Error::Other(anyhow::anyhow!(
            "zig no encontrado en {}/zig — ¿instalaste zig en .dev-fs/tools/zig?",
            zig_dir.display()
        )));
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn push_tail_keeps_last_n() {
        let mut buf = VecDeque::new();
        for i in 0..10 {
            push_tail(&mut buf, format!("line {i}"), 3);
        }
        let got: Vec<_> = buf.iter().cloned().collect();
        assert_eq!(got, vec!["line 7", "line 8", "line 9"]);
    }

    #[test]
    fn build_failure_roundtrips_through_core_error() {
        // El contrato que usa el bus: envolver en Error::Other y recuperar por downcast.
        let bf = BuildFailure {
            reason: "exit 2".into(),
            log_tail: Some("undefined reference to `foo'".into()),
        };
        let err = hammer_core::Error::Other(anyhow::Error::new(bf));
        let recovered = BuildFailure::from_error(&err).expect("debe recuperarse");
        assert_eq!(recovered.reason, "exit 2");
        assert_eq!(
            recovered.log_tail.as_deref(),
            Some("undefined reference to `foo'")
        );
    }

    #[test]
    fn from_error_none_for_plain_errors() {
        let err = hammer_core::Error::Recipe("nope".into());
        assert!(BuildFailure::from_error(&err).is_none());
    }

    fn fixture(deps: Vec<PathBuf>) -> Sandbox {
        Sandbox {
            rootfs: PathBuf::from("/rootfs"),
            zig_dir: PathBuf::from("/zig"),
            src_dir: PathBuf::from("/src-host"),
            out_dir: PathBuf::from("/out-host"),
            cache_dir: None,
            deps,
            env: vec![],
        }
    }

    #[test]
    fn no_deps_emits_single_overlay_src() {
        // Compat hacia atrás: sin deps, una sola capa overlay (el rootfs) — sandbox idéntico al previo.
        let args = fixture(vec![]).bwrap_args("true");
        let n = args.iter().filter(|a| *a == "--overlay-src").count();
        assert_eq!(n, 1, "sin deps ⇒ un único --overlay-src");
        // El --tmp-overlay viene inmediatamente tras el rootfs.
        let i = args.iter().position(|a| a == "--overlay-src").unwrap();
        assert_eq!(args[i + 1], "/rootfs");
        assert_eq!(args[i + 2], "--tmp-overlay");
    }

    #[test]
    fn deps_stack_as_overlay_layers_under_rootfs() {
        let args = fixture(vec![PathBuf::from("/dep/libcap"), PathBuf::from("/dep/zlib")])
            .bwrap_args("true");
        // rootfs + 2 deps = 3 capas overlay, todas antes del --tmp-overlay.
        let srcs: Vec<&String> = args
            .iter()
            .enumerate()
            .filter(|(_, a)| *a == "--overlay-src")
            .map(|(i, _)| &args[i + 1])
            .collect();
        assert_eq!(srcs, vec!["/rootfs", "/dep/libcap", "/dep/zlib"]);
        let to = args.iter().position(|a| a == "--tmp-overlay").unwrap();
        let last_src = args.iter().rposition(|a| a == "--overlay-src").unwrap();
        assert!(last_src < to, "todas las capas overlay van antes del --tmp-overlay");
    }
}