//! simi — el `/bin/sh` del producto.
//!
//! «simi» es *boca, lengua* en quechua: es cómo se le habla a la máquina.
//!
//! **Por qué existe.** El frente C del ADR 0008 pone a busybox en la raíz de confianza del arranque
//! (`STAGE1_COMPONENTS`, `ATTEST_PATHS`) y en el `exec` de cada card de arje. Botarlo pedía un `sh`,
//! y el candidato que se midió —brush 0.4.0— pesa 6,9 MB, arranca 3,7× más lento que el ash de
//! busybox y trae dos divergencias medidas contra POSIX (reubeno/brush#1394 y #1396).
//!
//! **Alcance, y está MEDIDO, no supuesto** (`docs/plan-botar-busybox.md`):
//!
//! | consumidor | qué usa |
//! |---|---|
//! | las 23 cards de arje con shell | 8 builtins, 13 construcciones, ninguna función, ningún `if` |
//! | los 21 `/init` empotrados de las imágenes | + `if`, funciones, `case`, aquí-documentos, `${…}`, posicionales |
//! | `takana-live-install.sh` (corre en la imagen viva) | POSIX entero |
//!
//! Lo que NO está y se dice en vez de fingirlo: control de trabajos (`jobs`/`fg`/`bg`), edición de
//! línea, historial, `alias`, `getopts`, `[[ ]]`, arrays. El shell interactivo de `getty` es otro
//! consumidor y no está cubierto todavía.
//!
//! **Extensiones NO-POSIX que sí están** (2026-10-22, a pedido explícito del usuario: «si hay
//! mejoras que no rompan posix, hazles»). POSIX deja esta sintaxis **sin definir**, así que un
//! script conforme nunca la escribe y soportarla no puede cambiarle el comportamiento a nadie —
//! verificado: el banco diferencial sigue en **DIVERGE=0** sobre 1339 casos, y el banco POSIX da
//! los MISMOS 2 fallos preexistentes (`while-read`, `getopts`) antes y después.
//!
//! | forma | qué hace |
//! |---|---|
//! | `${x/pat/rep}` `${x//pat/rep}` | sustituir la primera / todas. Patrón glob, coincidencia más larga y más a la izquierda |
//! | `${x/#pat/rep}` `${x/%pat/rep}` | anclado al principio / al final |
//! | `${x:desde}` `${x:desde:largo}` | subcadena; los dos índices son expresiones ARITMÉTICAS y un negativo cuenta desde el final |
//! | `${x^}` `${x^^}` `${x,}` `${x,,}` | caja: primera letra o todas |
//!
//! ⚠ **`${!x}` (indirección) NO se añadió**, y es deliberado: choca con el `$!` que el lexer ya
//! trata como nombre especial, y era la menos usada de las cuatro. Se dice en vez de fingirlo.
//!
//! Por qué se añadieron: el corpus las usa. `${t/unknown-/}` en `wasi-libcxx` era la ÚNICA
//! divergencia de simi en 1339 casos, y rechazarla obligaba a reescribir recetas por una razón
//! ajena a lo que la receta hace.
//!
//! Uso: `simi [-c ORDEN | FICHERO] [-e] [-u] [-x] [-n] [ARGS…]`, y por stdin si no hay ninguno.

mod arith;
mod ast;
mod builtins;
mod exec;
mod expand;
mod glob;
mod lexer;
mod linea;
mod parser;
mod shell;

use std::io::Read;

use shell::{Flujo, Shell};

fn main() -> std::process::ExitCode {
    let args: Vec<String> = std::env::args().collect();
    let mut sh = Shell::nuevo();
    // argv[0] con guión delante = shell de login; hoy sólo cambia el nombre en los mensajes.
    let argv0 = args.first().cloned().unwrap_or_else(|| "simi".into());
    sh.nombre = argv0.trim_start_matches('-').rsplit('/').next().unwrap_or("simi").to_string();

    let mut i = 1;
    let mut orden: Option<String> = None;
    let mut fichero: Option<String> = None;
    while i < args.len() {
        let a = &args[i];
        match a.as_str() {
            "-c" => {
                i += 1;
                match args.get(i) {
                    Some(c) => orden = Some(c.clone()),
                    None => {
                        eprintln!("{}: -c necesita una orden", sh.nombre);
                        return std::process::ExitCode::from(2);
                    }
                }
            }
            "-s" => {}
            "--" => {
                i += 1;
                break;
            }
            _ if a.starts_with('-') && a.len() > 1 && !a.starts_with("--") => {
                for c in a[1..].chars() {
                    match c {
                        'e' => sh.opts.errexit = true,
                        'u' => sh.opts.nounset = true,
                        'x' => sh.opts.xtrace = true,
                        'n' => sh.opts.noexec = true,
                        'f' => sh.opts.noglob = true,
                        'i' | 'l' => {}
                        otro => {
                            eprintln!("{}: -{otro}: opción no soportada", sh.nombre);
                            return std::process::ExitCode::from(2);
                        }
                    }
                }
            }
            _ => {
                if orden.is_none() {
                    fichero = Some(a.clone());
                }
                break;
            }
        }
        i += 1;
    }

    // Los argumentos que quedan son los posicionales. Con `-c`, el primero es `$0`.
    let resto: Vec<String> = args[i..].to_vec();
    let texto = match (&orden, &fichero) {
        (Some(c), _) => {
            if !resto.is_empty() {
                sh.nombre = resto[0].clone();
                sh.params = resto[1..].to_vec();
            }
            c.clone()
        }
        (None, Some(f)) => {
            sh.nombre = f.clone();
            sh.params = resto[1..].to_vec();
            match std::fs::read_to_string(f) {
                Ok(t) => t,
                Err(e) => {
                    eprintln!("{}: {}: {}", argv0, f, e);
                    return std::process::ExitCode::from(127);
                }
            }
        }
        (None, None) => {
            // ⚠ **Sin fichero ni `-c` hay DOS caminos, y antes había uno.** Si la entrada es una
            // TERMINAL, esto es un shell interactivo y entra al REPL con editor de línea,
            // historial y Tab (`linea.rs`). Si no lo es —una tubería, `simi < guion`— se traga la
            // entrada y se ejecuta como script, que es el comportamiento de siempre y el que usan
            // las cards y los `/init`.
            //
            // La distinción es `isatty(0)`, no una bandera: un shell que decide esto por una
            // opción se equivoca el día que alguien lo invoque de la otra forma.
            if unsafe { libc::isatty(libc::STDIN_FILENO) } == 1 {
                return repl(&mut sh);
            }
            let mut t = String::new();
            if std::io::stdin().read_to_string(&mut t).is_err() {
                eprintln!("{}: no pude leer la entrada", sh.nombre);
                return std::process::ExitCode::from(2);
            }
            t
        }
    };

    let lista = match parser::parsear(&texto) {
        Ok(l) => l,
        Err(e) => {
            eprintln!("{}: error de sintaxis: {}", sh.nombre, e);
            return std::process::ExitCode::from(2);
        }
    };
    // `-n`: parsear y no ejecutar. Es lo que usa el banco diferencial, y lo que hace que un guion
    // roto se detecte sin correrlo.
    if sh.opts.noexec {
        return std::process::ExitCode::SUCCESS;
    }

    let flujo = exec::correr_lista(&mut sh, &lista);
    let estado = match flujo {
        Flujo::Exit(c) => c,
        _ => sh.estado,
    };
    exec::correr_trap_exit(&mut sh, estado);
    let final_ = if sh.trap_exit_corrido { estado } else { sh.estado };
    std::process::ExitCode::from((final_ & 0xff) as u8)
}

/// El bucle interactivo. Separado de la ruta de script a propósito: lee UNA orden, la ejecuta y
/// vuelve, de modo que un error de sintaxis o un fallo de la orden no termina la sesión — que es
/// justo lo contrario de lo que debe hacer un script.
fn repl(sh: &mut Shell) -> std::process::ExitCode {
    let mut ed = linea::Editor::nuevo();
    // `PS1` por defecto si nadie la puso. Se ASIGNA (no sólo se usa) para que `echo $PS1` la vea,
    // que es lo que alguien espera al entrar.
    if sh.leer("PS1").is_none() {
        sh.asignar("PS1", "\\u@\\h:\\w\\$ ");
    }
    let mut ultimo = 0i32;
    loop {
        let p = linea::prompt(sh);
        match ed.leer(&p) {
            linea::Linea::Fin => break,
            linea::Linea::Interrumpida => {
                // Ctrl-C: `$?` pasa a 130 como en bash (128 + SIGINT), y se sigue.
                ultimo = 130;
                sh.estado = 130;
                continue;
            }
            linea::Linea::Texto(t) => {
                if t.trim().is_empty() {
                    continue;
                }
                match parser::parsear(&t) {
                    Ok(lista) => {
                        // `correr_lista` devuelve `Flujo`, no un código: un `exit` escrito en el
                        // prompt tiene que TERMINAR la sesión con su código, y el resto de los
                        // flujos (`break`/`continue` sueltos) no significan nada acá y se ignoran.
                        match exec::correr_lista(sh, &lista) {
                            Flujo::Exit(c) => {
                                ultimo = c;
                                break;
                            }
                            _ => ultimo = sh.estado,
                        }
                    }
                    Err(e) => {
                        // Un error de sintaxis en interactivo NO mata la sesión: se avisa y se
                        // sigue. `2` es el código que POSIX pide para un error de sintaxis.
                        eprintln!("{}: {e}", sh.nombre);
                        ultimo = 2;
                        sh.estado = 2;
                    }
                }
            }
        }
    }
    // El historial se guarda ANTES del trap de salida: si el trap aborta, lo tecleado no se pierde.
    ed.guardar();
    exec::correr_trap_exit(sh, ultimo);
    let final_ = if sh.trap_exit_corrido { ultimo } else { sh.estado };
    std::process::ExitCode::from((final_ & 0xff) as u8)
}