//! El árbol del programa.

use std::rc::Rc;
use crate::regex::Regex;

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum BinOp { Suma, Resta, Mult, Div, Modulo, Potencia }

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum CmpOp { Lt, Le, Gt, Ge, Eq, Ne }

#[derive(Clone)]
pub enum Expr {
    Num(f64),
    Cad(String),
    /// Una ERE suelta: como expresión vale `$0 ~ /re/`.
    Ere(Rc<Regex>),
    Var(String),
    Campo(Box<Expr>),
    /// `a[i]`, `a[i,j]` (los índices se unen con SUBSEP).
    Indice(String, Vec<Expr>),
    Asigna(Box<Lugar>, Box<Expr>),
    /// `+=`, `-=`, … con su operador.
    AsignaOp(Box<Lugar>, BinOp, Box<Expr>),
    Bin(BinOp, Box<Expr>, Box<Expr>),
    Cmp(CmpOp, Box<Expr>, Box<Expr>),
    /// `~` y `!~`. El segundo `bool` dice si está negado.
    Coincide(Box<Expr>, Box<Expr>, bool),
    Y(Box<Expr>, Box<Expr>),
    O(Box<Expr>, Box<Expr>),
    No(Box<Expr>),
    Neg(Box<Expr>),
    Pos(Box<Expr>),
    Ternario(Box<Expr>, Box<Expr>, Box<Expr>),
    /// Concatenación por yuxtaposición: `a b`.
    Concat(Box<Expr>, Box<Expr>),
    /// `++x` / `x++` (y `--`). `previo` = es prefijo.
    Incr(Box<Lugar>, bool, f64),
    /// `(i, j) in a` y `i in a`.
    En(Vec<Expr>, String),
    Llamada(String, Vec<Expr>),
    Builtin(String, Vec<Expr>),
    /// `getline` en sus cuatro formas.
    Getline(Getline),
    /// `(expr)` agrupada: hay que recordarlo para distinguir `(a,b) in arr` de una lista.
    Grupo(Box<Expr>),
}

#[derive(Clone)]
pub enum Getline {
    /// `getline [lugar]` — de la entrada normal.
    Simple(Option<Box<Lugar>>),
    /// `getline [lugar] < "fichero"`.
    DeFichero(Option<Box<Lugar>>, Box<Expr>),
    /// `"cmd" | getline [lugar]`.
    DeTuberia(Box<Expr>, Option<Box<Lugar>>),
}

/// Algo a lo que se puede asignar.
#[derive(Clone)]
pub enum Lugar {
    Var(String),
    Campo(Box<Expr>),
    Indice(String, Vec<Expr>),
}

#[derive(Clone)]
pub enum Redir {
    /// `> f`
    Fichero(Box<Expr>),
    /// `>> f`
    Anexa(Box<Expr>),
    /// `| "cmd"`
    Tuberia(Box<Expr>),
}

#[derive(Clone)]
pub enum Sent {
    Expr(Expr),
    Print(Vec<Expr>, Option<Redir>),
    Printf(Vec<Expr>, Option<Redir>),
    Bloque(Vec<Sent>),
    Si(Expr, Box<Sent>, Option<Box<Sent>>),
    Mientras(Expr, Box<Sent>),
    HazMientras(Box<Sent>, Expr),
    /// `for (init; cond; paso) cuerpo`
    Para(Option<Box<Sent>>, Option<Expr>, Option<Box<Sent>>, Box<Sent>),
    /// `for (k in a) cuerpo`
    ParaEn(String, String, Box<Sent>),
    Corta,
    Sigue,
    Siguiente,
    SiguienteFichero,
    Sale(Option<Expr>),
    Retorna(Option<Expr>),
    Borra(String, Vec<Expr>),
    /// `delete a` entero.
    BorraTodo(String),
    Nada,
}

#[derive(Clone)]
pub enum Patron {
    Begin,
    End,
    /// Sin patrón: la acción corre para cada registro.
    Siempre,
    Expr(Expr),
    /// `expr1, expr2` — rango. El `bool` es el estado (dentro/fuera), que vive en el intérprete.
    Rango(Expr, Expr),
}

#[derive(Clone)]
pub struct Regla {
    pub patron: Patron,
    pub accion: Option<Vec<Sent>>,
    /// Índice del estado de rango, para las reglas `expr1, expr2`.
    pub rango_id: usize,
}

#[derive(Clone)]
pub struct Funcion {
    pub nombre: String,
    pub params: Vec<String>,
    pub cuerpo: Vec<Sent>,
}

#[derive(Clone, Default)]
pub struct Programa {
    pub reglas: Vec<Regla>,
    pub funciones: Vec<Funcion>,
    pub rangos: usize,
}