//! Entradas de arranque UEFI (ADR 0018 §1/§3): construir un `EFI_LOAD_OPTION` y publicarlo en la
//! NVRAM del firmware por `efivarfs`.
//!
//! ── POR QUÉ ESTO Y NO `efibootmgr` ──────────────────────────────────────────────────────────────
//! El ADR 0018 dejaba abiertas las dos vías. Se intentó primero la ajena y **se midió el muro**
//! (2026-09-11): `efivar` 38 con musl/zig-cc choca con `secure_getenv` (no existe en musl),
//! `sys/cdefs.h` (tampoco) y `-Wl,--add-needed` (lld lo rechaza) — tres muros sólo para llegar a
//! compilar su generador de tablas, que es el patrón «pantano de parches de distro». Y arrastraría
//! además `popt` al sistema instalado.
//!
//! Lo que efibootmgr hace, en el fondo, es **escribir dos ficheros**: `Boot####` y `BootOrder`. El
//! formato es una estructura de la spec UEFI, estable desde 2.0 y de tamaño fijo. Escribirla acá es
//! menos código que mantener los parches, no agrega dependencias al sistema instalado, y el binario
//! `takana` ya está en el disco.
//!
//! ── LA ESTRUCTURA, QUE ES TODO LO QUE HAY QUE ACERTAR ───────────────────────────────────────────
//! `EFI_LOAD_OPTION` (UEFI 2.10 §3.1.3) — todo little-endian, sin relleno:
//!
//! ```text
//!   u32   Attributes            LOAD_OPTION_ACTIVE = 1
//!   u16   FilePathListLength    bytes del device path, NO del total
//!   u16[] Description           UTF-16LE terminada en NUL
//!   u8[]  FilePathList          el device path completo, incluido su nodo final
//!   u8[]  OptionalData          lo que el firmware pasa como LoadOptions (acá: vacío)
//! ```
//!
//! El device path para «un fichero dentro de una partición» son tres nodos encadenados, cada uno con
//! su cabecera `(type: u8, subtype: u8, length: u16)` donde `length` **se cuenta con la cabecera**:
//!
//! ```text
//!   MEDIA/HARD_DRIVE (4/1, 42 bytes): nº de partición, LBA de inicio, LBA de tamaño,
//!                                     firma (16 B), tipo de MBR (1=MBR, 2=GPT), tipo de firma
//!   MEDIA/FILE_PATH  (4/4, variable): la ruta en UTF-16LE con `\` de separador, terminada en NUL
//!   END              (0x7F/0xFF, 4 bytes)
//! ```
//!
//! ⚠ **Un device path mal formado no da error: el firmware ignora la entrada en silencio** y el
//! usuario ve «no arranca» sin una sola pista. Por eso `parse_load_option` existe y por eso el
//! round-trip se prueba contra bytes REALES del firmware, no sólo contra vectores escritos a mano.

use std::io;
use std::path::{Path, PathBuf};

/// GUID del espacio de variables globales de EFI (`EFI_GLOBAL_VARIABLE`).
pub const GLOBAL_GUID: &str = "8be4df61-93ca-11d2-aa0d-00e098032b8c";
/// Raíz de `efivarfs`. El firmware sólo existe detrás de esto.
pub const EFIVARS: &str = "/sys/firmware/efi/efivars";

/// NON_VOLATILE | BOOTSERVICE_ACCESS | RUNTIME_ACCESS. Sin las tres, la entrada no sobrevive al
/// apagado o no la ve el gestor de arranque.
pub const ATTRS: u32 = 0x0000_0007;
/// `LOAD_OPTION_ACTIVE` — sin esto la entrada existe y el firmware NO la arranca.
pub const LOAD_OPTION_ACTIVE: u32 = 0x0000_0001;

/// La partición donde vive el `.efi`, tal como la describe el nodo HARD_DRIVE.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HdPartition {
    pub number: u32,
    pub start_lba: u64,
    pub size_lba: u64,
    pub signature: [u8; 16],
    /// 1 = tabla MBR, 2 = tabla GPT.
    pub mbr_type: u8,
    /// 1 = firma de MBR (4 bytes útiles), 2 = GUID de partición GPT.
    pub sig_type: u8,
}

/// Una entrada `Boot####` decodificada.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LoadOption {
    pub attributes: u32,
    pub description: String,
    pub file_path_list: Vec<u8>,
    pub optional_data: Vec<u8>,
}

fn utf16_nul(s: &str) -> Vec<u8> {
    let mut v: Vec<u8> = s.encode_utf16().flat_map(|u| u.to_le_bytes()).collect();
    v.extend_from_slice(&[0, 0]);
    v
}

/// Nodo MEDIA/HARD_DRIVE: 42 bytes exactos, y el firmware los cuenta.
pub fn hd_node(p: &HdPartition) -> Vec<u8> {
    let mut v = Vec::with_capacity(42);
    v.extend_from_slice(&[0x04, 0x01]);
    v.extend_from_slice(&42u16.to_le_bytes());
    v.extend_from_slice(&p.number.to_le_bytes());
    v.extend_from_slice(&p.start_lba.to_le_bytes());
    v.extend_from_slice(&p.size_lba.to_le_bytes());
    v.extend_from_slice(&p.signature);
    v.push(p.mbr_type);
    v.push(p.sig_type);
    debug_assert_eq!(v.len(), 42);
    v
}

/// Nodo MEDIA/FILE_PATH. La ruta va con `\` (separador de la spec), no con `/`.
pub fn file_node(path_efi: &str) -> Vec<u8> {
    let p = path_efi.replace('/', "\\");
    let s = utf16_nul(&p);
    let len = (4 + s.len()) as u16;
    let mut v = Vec::with_capacity(len as usize);
    v.extend_from_slice(&[0x04, 0x04]);
    v.extend_from_slice(&len.to_le_bytes());
    v.extend_from_slice(&s);
    v
}

/// Nodo final. Sin él, el firmware sigue leyendo memoria que no es suya.
pub fn end_node() -> Vec<u8> {
    vec![0x7f, 0xff, 0x04, 0x00]
}

pub fn device_path(part: &HdPartition, path_efi: &str) -> Vec<u8> {
    let mut v = hd_node(part);
    v.extend(file_node(path_efi));
    v.extend(end_node());
    v
}

/// Serializa un `EFI_LOAD_OPTION` completo (sin los 4 bytes de atributos de efivarfs).
pub fn load_option(description: &str, device_path: &[u8], optional_data: &[u8]) -> Vec<u8> {
    let desc = utf16_nul(description);
    let mut v = Vec::with_capacity(4 + 2 + desc.len() + device_path.len() + optional_data.len());
    v.extend_from_slice(&LOAD_OPTION_ACTIVE.to_le_bytes());
    v.extend_from_slice(&(device_path.len() as u16).to_le_bytes());
    v.extend_from_slice(&desc);
    v.extend_from_slice(device_path);
    v.extend_from_slice(optional_data);
    v
}

/// Decodifica un `EFI_LOAD_OPTION`. Es la mitad que permite COMPROBAR la otra: si `parse(build(x))`
/// no devuelve `x`, el que está mal es el constructor, y eso se ve acá en vez de en el firmware.
pub fn parse_load_option(b: &[u8]) -> Result<LoadOption, String> {
    if b.len() < 6 {
        return Err(format!("EFI_LOAD_OPTION truncado: {} bytes, mínimo 6", b.len()));
    }
    let attributes = u32::from_le_bytes([b[0], b[1], b[2], b[3]]);
    let fpl = u16::from_le_bytes([b[4], b[5]]) as usize;
    // La descripción es UTF-16 hasta el primer u16 nulo.
    let mut i = 6;
    let mut units: Vec<u16> = Vec::new();
    loop {
        if i + 1 >= b.len() {
            return Err("descripción sin terminador NUL".into());
        }
        let u = u16::from_le_bytes([b[i], b[i + 1]]);
        i += 2;
        if u == 0 {
            break;
        }
        units.push(u);
    }
    let description = String::from_utf16_lossy(&units);
    if i + fpl > b.len() {
        return Err(format!(
            "FilePathListLength={fpl} excede el buffer ({} bytes restantes)",
            b.len() - i
        ));
    }
    let file_path_list = b[i..i + fpl].to_vec();
    let optional_data = b[i + fpl..].to_vec();
    Ok(LoadOption { attributes, description, file_path_list, optional_data })
}

/// Ruta de la variable `Boot####` en efivarfs.
pub fn boot_var_path(root: &Path, num: u16) -> PathBuf {
    root.join(format!("Boot{num:04X}-{GLOBAL_GUID}"))
}

/// Escribe una variable EFI: los 4 bytes de atributos van PEGADOS al dato, y todo en UNA sola
/// escritura — efivarfs rechaza la variable si llega partida en dos `write()`.
pub fn write_var(path: &Path, attrs: u32, data: &[u8]) -> io::Result<()> {
    use std::io::Write;
    let mut buf = Vec::with_capacity(4 + data.len());
    buf.extend_from_slice(&attrs.to_le_bytes());
    buf.extend_from_slice(data);
    let mut f = std::fs::OpenOptions::new().write(true).create(true).truncate(true).open(path)?;
    f.write_all(&buf)?;
    f.flush()
}

/// Lee una variable EFI y devuelve `(attrs, data)` ya sin la cabecera de 4 bytes.
pub fn read_var(path: &Path) -> io::Result<(u32, Vec<u8>)> {
    let raw = std::fs::read(path)?;
    if raw.len() < 4 {
        return Err(io::Error::new(
            io::ErrorKind::InvalidData,
            format!("variable EFI de {} bytes: no entra ni la cabecera de atributos", raw.len()),
        ));
    }
    Ok((u32::from_le_bytes([raw[0], raw[1], raw[2], raw[3]]), raw[4..].to_vec()))
}

/// `BootOrder` es un array de u16 little-endian: el orden en que el firmware prueba las entradas.
pub fn parse_boot_order(data: &[u8]) -> Vec<u16> {
    data.chunks_exact(2).map(|c| u16::from_le_bytes([c[0], c[1]])).collect()
}

pub fn serialize_boot_order(order: &[u16]) -> Vec<u8> {
    order.iter().flat_map(|n| n.to_le_bytes()).collect()
}

/// Pone `num` PRIMERO y conserva el resto sin duplicarlo. Idempotente a propósito: el reconciliador
/// del ADR 0018 §2 corre en CADA arranque, así que la operación tiene que poder repetirse sin
/// acumular basura ni alterar nada cuando ya está bien.
pub fn promote_first(order: &[u16], num: u16) -> Vec<u16> {
    let mut v = vec![num];
    v.extend(order.iter().copied().filter(|&x| x != num));
    v
}

/// Lee del DISCO los datos de la partición `number` para armar el nodo HARD_DRIVE.
///
/// Detecta sola la tabla: si el LBA 1 empieza con `EFI PART` es GPT; si no, se trata como MBR. Los
/// dos casos hacen falta — `install-image-efi.sh` fabrica GPT y `takana-live-install.sh` instala
/// sobre **MBR** (una ESP de tipo 0xEF en tabla MBR arranca igual por UEFI).
///
/// ⚠ Asume sectores lógicos de 512 B. En un disco 4Kn los offsets del GPT se corren y esto lee
/// basura: por eso valida la firma y el número de partición en vez de confiar, y falla ruidosamente.
pub fn read_partition(disk: &Path, number: u32) -> io::Result<HdPartition> {
    use std::io::{Read, Seek, SeekFrom};
    if number == 0 {
        return Err(io::Error::new(io::ErrorKind::InvalidInput, "el nº de partición empieza en 1"));
    }
    let mut f = std::fs::File::open(disk)?;

    // --- ¿GPT? El header vive en el LBA 1 y empieza con la firma "EFI PART". ---
    let mut hdr = [0u8; 512];
    f.seek(SeekFrom::Start(512))?;
    f.read_exact(&mut hdr)?;
    if &hdr[0..8] == b"EFI PART" {
        let entry_lba = u64::from_le_bytes(hdr[72..80].try_into().unwrap());
        let n_entries = u32::from_le_bytes(hdr[80..84].try_into().unwrap());
        let entry_sz = u32::from_le_bytes(hdr[84..88].try_into().unwrap()) as usize;
        if number > n_entries {
            return Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                format!("la partición {number} no existe: el GPT declara {n_entries}"),
            ));
        }
        if entry_sz < 56 || entry_sz > 4096 {
            return Err(io::Error::new(
                io::ErrorKind::InvalidData,
                format!("SizeOfPartitionEntry absurdo ({entry_sz}): ¿sectores de 4K?"),
            ));
        }
        let off = entry_lba * 512 + (number as u64 - 1) * entry_sz as u64;
        let mut e = vec![0u8; entry_sz];
        f.seek(SeekFrom::Start(off))?;
        f.read_exact(&mut e)?;
        if e[0..16] == [0u8; 16] {
            return Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                format!("la entrada GPT {number} está VACÍA (PartitionTypeGUID todo ceros)"),
            ));
        }
        let start = u64::from_le_bytes(e[32..40].try_into().unwrap());
        let end = u64::from_le_bytes(e[40..48].try_into().unwrap());
        let mut signature = [0u8; 16];
        // El GUID se copia CRUDO, en el mismo orden mixto que tiene en disco: es lo que el firmware
        // compara byte a byte contra su propia lectura de la tabla.
        signature.copy_from_slice(&e[16..32]);
        return Ok(HdPartition {
            number,
            start_lba: start,
            size_lba: end.saturating_sub(start) + 1,
            signature,
            mbr_type: 2,
            sig_type: 2,
        });
    }

    // --- MBR: la "firma" son los 4 bytes del NT disk signature en 0x1B8. ---
    let mut mbr = [0u8; 512];
    f.seek(SeekFrom::Start(0))?;
    f.read_exact(&mut mbr)?;
    if mbr[510] != 0x55 || mbr[511] != 0xAA {
        return Err(io::Error::new(
            io::ErrorKind::InvalidData,
            "ni GPT ni MBR: falta la firma 0x55AA del sector de arranque",
        ));
    }
    if number > 4 {
        return Err(io::Error::new(
            io::ErrorKind::InvalidInput,
            format!("MBR sólo tiene 4 primarias; pediste la {number}"),
        ));
    }
    let e = &mbr[446 + (number as usize - 1) * 16..][..16];
    if e[4] == 0 {
        return Err(io::Error::new(
            io::ErrorKind::InvalidInput,
            format!("la partición MBR {number} está vacía (tipo 0x00)"),
        ));
    }
    let start = u32::from_le_bytes(e[8..12].try_into().unwrap()) as u64;
    let size = u32::from_le_bytes(e[12..16].try_into().unwrap()) as u64;
    let mut signature = [0u8; 16];
    signature[0..4].copy_from_slice(&mbr[0x1b8..0x1bc]);
    Ok(HdPartition { number, start_lba: start, size_lba: size, signature, mbr_type: 1, sig_type: 1 })
}

/// GUID de tipo «EFI System Partition», tal como se almacena en la tabla GPT: los tres primeros
/// campos van en little-endian y los dos últimos crudos. Escribirlo en el orden «legible» es el
/// error clásico y no casaría con ninguna ESP del mundo.
pub const ESP_TYPE_GUID: [u8; 16] = [
    0x28, 0x73, 0x2a, 0xc1, 0x1f, 0xf8, 0xd2, 0x11, 0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b,
];

/// Discos de bloque reales del sistema, sin los virtuales. Un `loop` o un `ram` con una tabla de
/// particiones existe y NO es de donde arrancamos.
pub fn block_disks(sys_block: &Path) -> io::Result<Vec<PathBuf>> {
    let mut v = Vec::new();
    for ent in std::fs::read_dir(sys_block)? {
        let name = ent?.file_name().to_string_lossy().to_string();
        if name.starts_with("loop")
            || name.starts_with("ram")
            || name.starts_with("zram")
            || name.starts_with("dm-")
            || name.starts_with("sr")
        {
            continue;
        }
        let dev = PathBuf::from("/dev").join(&name);
        if dev.exists() {
            v.push(dev);
        }
    }
    v.sort();
    Ok(v)
}

/// Todas las ESP que haya, como `(disco, nº de partición)`.
///
/// Busca por **tipo de partición**, que es el único dato fiable sin montar nada: GUID de ESP en GPT,
/// tipo `0xEF` en MBR. No mira el contenido — para eso habría que montar la FAT, y un reconciliador
/// que monta sistemas de ficheros en el arranque es un efecto secundario que no queremos.
pub fn find_esps(disks: &[PathBuf]) -> Vec<(PathBuf, u32)> {
    let mut out = Vec::new();
    for d in disks {
        // GPT: hasta 128 entradas es lo habitual; read_partition ya valida el límite real.
        for n in 1..=128u32 {
            match read_partition(d, n) {
                Ok(_) => {
                    if es_esp(d, n).unwrap_or(false) {
                        out.push((d.clone(), n));
                    }
                }
                // La primera entrada vacía en MBR no significa que las siguientes lo estén, pero un
                // error de «no existe» sí corta: read_partition distingue los dos casos.
                Err(e) if e.kind() == io::ErrorKind::InvalidInput && n > 4 => break,
                Err(_) => continue,
            }
        }
    }
    out
}

/// ¿La partición `n` de `disk` es una ESP? Mira el tipo, no el contenido.
fn es_esp(disk: &Path, n: u32) -> io::Result<bool> {
    use std::io::{Read, Seek, SeekFrom};
    let mut f = std::fs::File::open(disk)?;
    let mut hdr = [0u8; 512];
    f.seek(SeekFrom::Start(512))?;
    f.read_exact(&mut hdr)?;
    if &hdr[0..8] == b"EFI PART" {
        let entry_lba = u64::from_le_bytes(hdr[72..80].try_into().unwrap());
        let entry_sz = u32::from_le_bytes(hdr[84..88].try_into().unwrap()) as usize;
        if !(56..=4096).contains(&entry_sz) {
            return Ok(false);
        }
        let mut e = vec![0u8; entry_sz];
        f.seek(SeekFrom::Start(entry_lba * 512 + (n as u64 - 1) * entry_sz as u64))?;
        f.read_exact(&mut e)?;
        return Ok(e[0..16] == ESP_TYPE_GUID);
    }
    // MBR: el tipo 0xEF es «EFI System Partition».
    let mut mbr = [0u8; 512];
    f.seek(SeekFrom::Start(0))?;
    f.read_exact(&mut mbr)?;
    if mbr[510] != 0x55 || mbr[511] != 0xAA || n > 4 {
        return Ok(false);
    }
    Ok(mbr[446 + (n as usize - 1) * 16 + 4] == 0xEF)
}

/// ¿Esta máquina arrancó por UEFI? Sin esto no hay NVRAM que reconciliar, y hay que decirlo en vez
/// de fallar con un error de fichero no encontrado que no explica nada.
pub fn hay_firmware_efi(efivars: &Path) -> bool {
    efivars.is_dir() && std::fs::read_dir(efivars).map(|mut d| d.next().is_some()).unwrap_or(false)
}

/// Busca el primer `Boot####` libre. Empieza en 0 porque es lo que hace todo el mundo y así el
/// número queda chico y legible en el menú del firmware.
pub fn first_free_slot(root: &Path) -> io::Result<u16> {
    for n in 0u16..=0xFFFF {
        if !boot_var_path(root, n).exists() {
            return Ok(n);
        }
    }
    Err(io::Error::new(io::ErrorKind::AlreadyExists, "no queda ni un Boot#### libre (0000-FFFF)"))
}

/// ¿Es una variable de **configuración** del arranque, y no estado de la sesión?
///
/// Lista blanca a propósito: sólo `BootOrder-<guid>` y `Boot####-<guid>`. Un «empieza por Boot» deja
/// entrar `BootCurrent` (por dónde arrancó esta vez — cambia en cada arranque y es de sólo lectura),
/// `BootOptionSupport` (informativa) y `BootNext` (de un solo uso: restaurarla dispararía un arranque
/// que nadie pidió). Ninguna de las tres describe cómo debe arrancar la máquina.
pub fn es_variable_de_config(nombre: &str) -> bool {
    let Some((base, guid)) = nombre.rsplit_once('-') else { return false };
    // El GUID lleva guiones: `rsplit_once` sólo corta el último trozo, así que se rearma mirando
    // el sufijo completo.
    let _ = (base, guid);
    let Some(resto) = nombre.strip_suffix(&format!("-{GLOBAL_GUID}")) else { return false };
    if resto == "BootOrder" {
        return true;
    }
    match resto.strip_prefix("Boot") {
        Some(n) => n.len() == 4 && n.chars().all(|c| c.is_ascii_hexdigit()),
        None => false,
    }
}

/// Lista las entradas `Boot####` presentes, en orden numérico, con su descripción ya decodificada.
pub fn list_entries(root: &Path) -> io::Result<Vec<(u16, LoadOption)>> {
    let mut out = Vec::new();
    for ent in std::fs::read_dir(root)? {
        let ent = ent?;
        let name = ent.file_name().to_string_lossy().to_string();
        let Some(rest) = name.strip_prefix("Boot") else { continue };
        let Some((num, guid)) = rest.split_once('-') else { continue };
        if !guid.eq_ignore_ascii_case(GLOBAL_GUID) || num.len() != 4 {
            continue;
        }
        let Ok(n) = u16::from_str_radix(num, 16) else { continue };
        let Ok((_, data)) = read_var(&ent.path()) else { continue };
        if let Ok(lo) = parse_load_option(&data) {
            out.push((n, lo));
        }
    }
    out.sort_by_key(|(n, _)| *n);
    Ok(out)
}

/// Qué tuvo que hacer una reconciliación. El ADR 0018 §2 exige que el reconciliador **reporte
/// cuando actúa**: si repara en silencio, el usuario convive con una rareza intermitente —«a veces
/// arranca Windows solo»— sin enterarse nunca de que hay un vecino pisando.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Reconciliacion {
    pub slot: u16,
    pub entrada_escrita: bool,
    pub orden_cambiado: bool,
    pub orden_antes: Vec<u16>,
    pub orden_despues: Vec<u16>,
}

impl Reconciliacion {
    /// ¿Hubo que tocar algo? Falso en el caso normal de un sistema que nadie pisó.
    pub fn actuo(&self) -> bool {
        self.entrada_escrita || self.orden_cambiado
    }
}

/// Deja la NVRAM diciendo lo que debe decir: una entrada para `loader` en `part`, y esa entrada
/// primera en `BootOrder`. **Idempotente**: si ya está así no escribe nada — importa porque esto
/// corre en cada arranque y la NVRAM tiene un número finito de ciclos de escritura.
pub fn reconcile(
    efivars: &Path,
    part: &HdPartition,
    loader: &str,
    label: &str,
    dry_run: bool,
) -> io::Result<Reconciliacion> {
    let dp = device_path(part, loader);
    let lo = load_option(label, &dp, &[]);

    let ya = list_entries(efivars)
        .unwrap_or_default()
        .into_iter()
        .find(|(_, e)| e.description == label && e.file_path_list == dp);

    let (slot, entrada_escrita) = match ya {
        Some((n, _)) => (n, false),
        None => {
            let n = first_free_slot(efivars)?;
            if !dry_run {
                write_var(&boot_var_path(efivars, n), ATTRS, &lo)?;
            }
            (n, true)
        }
    };

    let ruta_orden = efivars.join(format!("BootOrder-{GLOBAL_GUID}"));
    let orden_antes =
        read_var(&ruta_orden).map(|(_, d)| parse_boot_order(&d)).unwrap_or_default();
    let orden_despues = promote_first(&orden_antes, slot);
    let orden_cambiado = orden_despues != orden_antes;
    if orden_cambiado && !dry_run {
        write_var(&ruta_orden, ATTRS, &serialize_boot_order(&orden_despues))?;
    }

    Ok(Reconciliacion { slot, entrada_escrita, orden_cambiado, orden_antes, orden_despues })
}

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

    fn parte() -> HdPartition {
        HdPartition {
            number: 1,
            start_lba: 2048,
            size_lba: 131_072,
            signature: [
                0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee,
                0xff, 0x00,
            ],
            mbr_type: 2,
            sig_type: 2,
        }
    }

    #[test]
    fn hd_node_mide_42_y_pone_los_campos_donde_van() {
        let n = hd_node(&parte());
        assert_eq!(n.len(), 42, "el nodo HARD_DRIVE es de tamaño fijo por spec");
        assert_eq!(&n[0..2], &[0x04, 0x01], "type/subtype MEDIA/HARD_DRIVE");
        assert_eq!(u16::from_le_bytes([n[2], n[3]]), 42, "length se cuenta CON la cabecera");
        assert_eq!(u32::from_le_bytes([n[4], n[5], n[6], n[7]]), 1);
        assert_eq!(n[40], 2, "GPT");
        assert_eq!(n[41], 2, "firma = GUID");
    }

    #[test]
    fn file_node_usa_backslash_y_utf16() {
        let n = file_node("/EFI/takana/takanax64.efi");
        assert_eq!(&n[0..2], &[0x04, 0x04]);
        let len = u16::from_le_bytes([n[2], n[3]]) as usize;
        assert_eq!(len, n.len(), "el length declarado es el real");
        let units: Vec<u16> =
            n[4..].chunks_exact(2).map(|c| u16::from_le_bytes([c[0], c[1]])).collect();
        let s = String::from_utf16_lossy(&units[..units.len() - 1]);
        assert_eq!(s, "\\EFI\\takana\\takanax64.efi", "la spec separa con backslash");
    }

    #[test]
    fn round_trip_de_una_entrada_completa() {
        let dp = device_path(&parte(), "/EFI/takana/takanax64.efi");
        let lo = load_option("takana", &dp, &[]);
        let p = parse_load_option(&lo).expect("debe parsear lo que acabamos de construir");
        assert_eq!(p.description, "takana");
        assert_eq!(p.attributes, LOAD_OPTION_ACTIVE);
        assert_eq!(p.file_path_list, dp, "el device path vuelve entero y sin corrimiento");
        assert!(p.optional_data.is_empty());
    }

    #[test]
    fn el_device_path_termina_en_el_nodo_final() {
        let dp = device_path(&parte(), "/EFI/BOOT/BOOTX64.EFI");
        assert_eq!(&dp[dp.len() - 4..], &[0x7f, 0xff, 0x04, 0x00], "sin END el firmware se va de rango");
    }

    #[test]
    fn parse_rechaza_lo_truncado_en_vez_de_inventar() {
        assert!(parse_load_option(&[1, 0, 0]).is_err(), "6 bytes es el mínimo");
        // FilePathListLength que miente: dice más de lo que hay.
        let mut malo = load_option("x", &device_path(&parte(), "/a.efi"), &[]);
        malo[4] = 0xff;
        malo[5] = 0xff;
        assert!(parse_load_option(&malo).is_err(), "un fpl imposible debe FALLAR, no truncar");
    }

    #[test]
    fn promote_first_es_idempotente_y_no_duplica() {
        let o = vec![3u16, 1, 2];
        let a = promote_first(&o, 1);
        assert_eq!(a, vec![1, 3, 2]);
        assert_eq!(promote_first(&a, 1), a, "repetirlo no cambia nada: corre en CADA arranque");
        assert_eq!(promote_first(&[], 5), vec![5], "BootOrder vacío también es un caso");
    }

    /// Fabrica un disco GPT sintético (sin sfdisk: bytes a mano, determinista) con UNA partición.
    fn disco_gpt(tmp: &Path) -> PathBuf {
        let mut d = vec![0u8; 512 * 40];
        d[510] = 0x55;
        d[511] = 0xAA; // MBR protector
        let h = 512; // LBA 1 = header GPT
        d[h..h + 8].copy_from_slice(b"EFI PART");
        d[h + 72..h + 80].copy_from_slice(&2u64.to_le_bytes()); // PartitionEntryLBA
        d[h + 80..h + 84].copy_from_slice(&128u32.to_le_bytes()); // NumberOfPartitionEntries
        d[h + 84..h + 88].copy_from_slice(&128u32.to_le_bytes()); // SizeOfPartitionEntry
        let e = 512 * 2; // LBA 2 = primera entrada
        d[e..e + 16].copy_from_slice(&[0xAA; 16]); // PartitionTypeGUID (no nulo = ocupada)
        d[e + 16..e + 32].copy_from_slice(&[0x5A; 16]); // UniquePartitionGUID
        d[e + 32..e + 40].copy_from_slice(&2048u64.to_le_bytes()); // StartingLBA
        d[e + 40..e + 48].copy_from_slice(&133_119u64.to_le_bytes()); // EndingLBA (inclusive)
        let f = tmp.join("gpt.img");
        std::fs::write(&f, &d).unwrap();
        f
    }

    #[test]
    fn lee_una_particion_gpt_con_los_numeros_exactos() {
        let tmp = std::env::temp_dir().join(format!("takana-efi-gpt-{}", std::process::id()));
        std::fs::create_dir_all(&tmp).unwrap();
        let p = read_partition(&disco_gpt(&tmp), 1).expect("debe leer la partición 1");
        assert_eq!(p.number, 1);
        assert_eq!(p.start_lba, 2048);
        // size = end - start + 1, y el +1 importa: es un rango INCLUSIVO.
        assert_eq!(p.size_lba, 131_072, "EndingLBA es inclusivo");
        assert_eq!(p.signature, [0x5A; 16], "la firma es el GUID ÚNICO, no el de tipo");
        assert_eq!((p.mbr_type, p.sig_type), (2, 2), "GPT + firma GUID");
        std::fs::remove_dir_all(&tmp).ok();
    }

    #[test]
    fn rechaza_lo_que_no_es_tabla_y_la_particion_vacia() {
        let tmp = std::env::temp_dir().join(format!("takana-efi-neg-{}", std::process::id()));
        std::fs::create_dir_all(&tmp).unwrap();
        // Un disco sin firma 0x55AA no es ni GPT ni MBR: debe FALLAR, no devolver ceros.
        let basura = tmp.join("basura.img");
        std::fs::write(&basura, vec![0u8; 512 * 8]).unwrap();
        assert!(read_partition(&basura, 1).is_err(), "sin 0x55AA no hay tabla que leer");
        // Y una entrada GPT vacía tampoco se convierte en una partición de tamaño 0.
        let g = disco_gpt(&tmp);
        assert!(read_partition(&g, 2).is_err(), "la entrada 2 está vacía: error, no ceros");
        assert!(read_partition(&g, 0).is_err(), "las particiones empiezan en 1");
        std::fs::remove_dir_all(&tmp).ok();
    }

    #[test]
    fn lee_una_particion_mbr() {
        let tmp = std::env::temp_dir().join(format!("takana-efi-mbr-{}", std::process::id()));
        std::fs::create_dir_all(&tmp).unwrap();
        let mut d = vec![0u8; 512 * 4];
        d[0x1b8..0x1bc].copy_from_slice(&[0xDE, 0xAD, 0xBE, 0xEF]); // NT disk signature
        let e = 446;
        d[e + 4] = 0xEF; // tipo ESP
        d[e + 8..e + 12].copy_from_slice(&2048u32.to_le_bytes());
        d[e + 12..e + 16].copy_from_slice(&131_072u32.to_le_bytes());
        d[510] = 0x55;
        d[511] = 0xAA;
        let f = tmp.join("mbr.img");
        std::fs::write(&f, &d).unwrap();
        let p = read_partition(&f, 1).expect("debe leer la ESP del MBR");
        assert_eq!((p.start_lba, p.size_lba), (2048, 131_072));
        assert_eq!(&p.signature[0..4], &[0xDE, 0xAD, 0xBE, 0xEF]);
        assert_eq!((p.mbr_type, p.sig_type), (1, 1), "MBR + firma de MBR");
        std::fs::remove_dir_all(&tmp).ok();
    }

    #[test]
    fn el_guid_de_esp_esta_en_el_orden_DE_DISCO_y_no_en_el_legible() {
        // C12A7328-F81F-11D2-BA4B-00A0C93EC93B: los TRES primeros campos van en little-endian y los
        // dos últimos crudos. Escribirlo "como se lee" es el error clásico y no casaría con ninguna
        // ESP real — este test es la única forma de que se note acá y no en una máquina.
        assert_eq!(&ESP_TYPE_GUID[0..4], &[0x28, 0x73, 0x2a, 0xc1], "Data1 va invertido");
        assert_eq!(&ESP_TYPE_GUID[4..6], &[0x1f, 0xf8], "Data2 va invertido");
        assert_eq!(&ESP_TYPE_GUID[6..8], &[0xd2, 0x11], "Data3 va invertido");
        assert_eq!(&ESP_TYPE_GUID[8..16], &[0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b], "Data4 crudo");
    }

    #[test]
    fn encuentra_la_esp_por_tipo_y_no_se_inventa_otras() {
        let tmp = std::env::temp_dir().join(format!("takana-efi-esp-{}", std::process::id()));
        std::fs::create_dir_all(&tmp).unwrap();
        // Disco con DOS particiones: la 1 es ESP, la 2 no. Sólo debe salir la 1.
        let mut d = vec![0u8; 512 * 40];
        d[510] = 0x55;
        d[511] = 0xAA;
        let h = 512;
        d[h..h + 8].copy_from_slice(b"EFI PART");
        d[h + 72..h + 80].copy_from_slice(&2u64.to_le_bytes());
        d[h + 80..h + 84].copy_from_slice(&128u32.to_le_bytes());
        d[h + 84..h + 88].copy_from_slice(&128u32.to_le_bytes());
        let e1 = 512 * 2;
        d[e1..e1 + 16].copy_from_slice(&ESP_TYPE_GUID);
        d[e1 + 16..e1 + 32].copy_from_slice(&[0x5A; 16]);
        d[e1 + 32..e1 + 40].copy_from_slice(&2048u64.to_le_bytes());
        d[e1 + 40..e1 + 48].copy_from_slice(&133_119u64.to_le_bytes());
        let e2 = e1 + 128;
        d[e2..e2 + 16].copy_from_slice(&[0xBB; 16]); // otro tipo cualquiera
        d[e2 + 16..e2 + 32].copy_from_slice(&[0x6B; 16]);
        d[e2 + 32..e2 + 40].copy_from_slice(&133_120u64.to_le_bytes());
        d[e2 + 40..e2 + 48].copy_from_slice(&264_191u64.to_le_bytes());
        let f = tmp.join("dos.img");
        std::fs::write(&f, &d).unwrap();
        let esps = find_esps(std::slice::from_ref(&f));
        assert_eq!(esps.len(), 1, "hay UNA sola ESP, no dos: {esps:?}");
        assert_eq!(esps[0].1, 1, "y es la partición 1");
        std::fs::remove_dir_all(&tmp).ok();
    }

    #[test]
    fn sin_firmware_efi_lo_dice_en_vez_de_fallar_raro() {
        let tmp = std::env::temp_dir().join(format!("takana-efi-novars-{}", std::process::id()));
        std::fs::create_dir_all(&tmp).unwrap();
        assert!(!hay_firmware_efi(&tmp), "un directorio VACÍO no es un firmware EFI");
        assert!(!hay_firmware_efi(&tmp.join("no-existe")), "y uno que no existe, tampoco");
        std::fs::write(tmp.join("algo"), b"x").unwrap();
        assert!(hay_firmware_efi(&tmp), "con al menos una variable, sí");
        std::fs::remove_dir_all(&tmp).ok();
    }

    /// El escenario que motiva el ADR entero: otro sistema operativo se instala, crea su entrada y
    /// se pone PRIMERO. El reconciliador debe reponer el orden — y **no** borrar al vecino.
    #[test]
    fn el_vecino_se_pone_primero_y_el_reconciliador_lo_repone_sin_borrarlo() {
        let tmp = std::env::temp_dir().join(format!("takana-efi-vecino-{}", std::process::id()));
        std::fs::create_dir_all(&tmp).unwrap();
        let p = parte();

        // 1) takana se instala.
        let r1 = reconcile(&tmp, &p, "/EFI/takana/takanax64.efi", "takana", false).unwrap();
        assert!(r1.entrada_escrita, "la primera vez hay que escribirla");
        assert_eq!(r1.orden_despues, vec![r1.slot]);

        // 2) llega el vecino: crea su entrada y se pone primero en BootOrder.
        let vecino = load_option("Windows Boot Manager", &end_node(), &[]);
        let slot_vecino = first_free_slot(&tmp).unwrap();
        write_var(&boot_var_path(&tmp, slot_vecino), ATTRS, &vecino).unwrap();
        let ruta_orden = tmp.join(format!("BootOrder-{GLOBAL_GUID}"));
        write_var(&ruta_orden, ATTRS, &serialize_boot_order(&[slot_vecino, r1.slot])).unwrap();

        // 3) siguiente arranque de takana.
        let r2 = reconcile(&tmp, &p, "/EFI/takana/takanax64.efi", "takana", false).unwrap();
        assert!(r2.actuo(), "tiene que DARSE CUENTA de que lo movieron");
        assert!(!r2.entrada_escrita, "la entrada seguía ahí: sólo cambió el orden");
        assert!(r2.orden_cambiado);
        assert_eq!(r2.orden_despues[0], r1.slot, "takana vuelve a ser la primera");
        assert!(
            r2.orden_despues.contains(&slot_vecino),
            "y el vecino SIGUE en la lista: takana se pone primera, no lo borra"
        );
        assert!(
            boot_var_path(&tmp, slot_vecino).exists(),
            "la entrada del vecino no se toca nunca"
        );

        // 4) y el arranque siguiente, con todo en su sitio, no hace nada.
        let r3 = reconcile(&tmp, &p, "/EFI/takana/takanax64.efi", "takana", false).unwrap();
        assert!(!r3.actuo(), "sin cambios no se escribe: la NVRAM tiene ciclos finitos");
        std::fs::remove_dir_all(&tmp).ok();
    }

    #[test]
    fn dry_run_no_escribe_ni_un_byte() {
        let tmp = std::env::temp_dir().join(format!("takana-efi-dry-{}", std::process::id()));
        std::fs::create_dir_all(&tmp).unwrap();
        let r = reconcile(&tmp, &parte(), "/EFI/takana/takanax64.efi", "takana", true).unwrap();
        assert!(r.actuo(), "reporta lo que HARÍA");
        assert_eq!(std::fs::read_dir(&tmp).unwrap().count(), 0, "y no dejó nada en el directorio");
        std::fs::remove_dir_all(&tmp).ok();
    }

    #[test]
    fn la_lista_blanca_deja_fuera_el_estado_de_la_sesion() {
        let g = GLOBAL_GUID;
        assert!(es_variable_de_config(&format!("BootOrder-{g}")));
        assert!(es_variable_de_config(&format!("Boot0004-{g}")));
        assert!(es_variable_de_config(&format!("BootFFFF-{g}")));
        // Las tres que rompían la idempotencia del respaldo o son de sólo lectura:
        assert!(!es_variable_de_config(&format!("BootCurrent-{g}")), "cambia en CADA arranque");
        assert!(!es_variable_de_config(&format!("BootNext-{g}")), "es de un solo uso");
        assert!(!es_variable_de_config(&format!("BootOptionSupport-{g}")), "informativa");
        // Y nada de otro namespace de GUID, aunque se llame parecido.
        assert!(!es_variable_de_config("Boot0004-11111111-2222-3333-4444-555555555555"));
        assert!(!es_variable_de_config("Boot004-{g}"), "3 dígitos no es un slot");
        assert!(!es_variable_de_config("BootOrder"), "sin GUID no es una variable EFI");
    }

    #[test]
    fn boot_order_ida_y_vuelta() {
        let o = vec![0x0001u16, 0x0000, 0x2001];
        assert_eq!(parse_boot_order(&serialize_boot_order(&o)), o);
        assert_eq!(parse_boot_order(&[1]), Vec::<u16>::new(), "un byte suelto se descarta, no rompe");
    }
}