#!/usr/bin/perl
# dat2cir: del .dsa a un netlist de SPICE, para correrlo con ngspice. Es el
# espejo de cir2dsa (slex/cir), que va del .cir al .dsa.
#
#     dat2cir caso.M.dsa              escribe caso.M.cir al lado
#     dat2cir caso.dat salida.cir     donde se diga
#     dat2cir -n caso.M.dsa           dice que haria y no escribe
#
# Trabaja desde el DATO (ver "1. el DATO", abajo): el .dsa --el formato-- lo
# lleva al dato d2datdinc, y de ese dato sale el netlist. Por el mismo camino
# entra un .d de SCEPTRE, que slex sigue leyendo, o un .dat ya hecho. El .ds
# no existe mas (18/11/2026: la cabecera y la ayuda todavia hablaban de
# ".d/.ds", de cuando nacio, el 19/10/2026, como traductor de esos dos).
#
# Lo que traduce es lo que traen los decks que Simusol escribe (medido sobre
# los 25 del corpus de simusol, ver MOTORES.md):
#
#   Tambien entra lo propio de siru (lo que trae el dato de un par M/DU):
#   secciones con guion bajo, ramas con el prefijo del modelo
#   (EB-E1, RB-R1...), T como variable de integracion, CONTROL_EQUATIONS
#   T<N como final de la corrida y la seccion DATA con llaves_resistivas.
#   Una llave SB va a SPICE COMO RESISTIVA (pedido del autor, 09/11/2026):
#   r = cond ? RON : ROFF, la condicion dentro de la ecuacion, igual que
#   libdin y que la exportacion FLLAVS a SCEPTRE; sin RON/ROFF se rechaza,
#   porque para ir directo ninguna llave puede quedar ideal.
#
#   EL OTRO CAMINO, EL COORDINADO (pedido del autor, 09/11/2026: "siru
#   resolviendo la topologia en cada paso y spice avanzando mientras las
#   llaves no cambien"): con --llaves la configuracion viene DADA y la
#   llave es ideal, no resistiva: cerrada es un corto exacto (una fuente de
#   0 V, que ademas da su corriente) y abierta es el circuito abierto (una
#   resistencia de 1e12, que deja el nodo conectado para ngspice). La
#   condicion NO va en la ecuacion: se imprime aparte, como una columna de
#   0/1 por llave, y quien conduce los intervalos --el lanzador-- mira esas
#   columnas para saber donde conmutar. Con --estado y --desde se reanuda
#   desde el estado que dejo el intervalo anterior.
#
#   ELEMENTS   R, C, L tal cual (con r={...} si el valor es una expresion);
#              E -> V (en SPICE, E es una fuente controlada) o B con V={...}
#              si el valor es una expresion; J -> B con I={...}. La corriente
#              de un elemento --IR5, J1 en OUTPUTS o en una expresion-- se
#              mide con una fuente de 0 V en serie, porque ngspice no vuelca
#              la corriente de una B ni de una R (medido: la .print entera se
#              descarta). Los nodos quedan como estan; 0 y GND son masa.
#   DEFINED PARAMETERS
#              P = constante           -> .param
#              P = expresion que varia -> una fuente B sobre un nodo propio,
#                                         y las referencias pasan a v(nodo)
#              DP = expresion          -> la derivada: una B que inyecta la
#                                         expresion en un capacitor de 1 F,
#                                         asi v(nodo) es la integral; el valor
#                                         inicial es el P = valor del deck
#   FUNCTIONS  TABLE n -> pwl(x, x1,y1, x2,y2, ...) donde se use (XTABLE(Tn,x)
#              o Tn(x)); una x repetida --el escalon de SCEPTRE-- se corre un
#              poco, porque pwl pide x creciente. NOMBRE(args) = (expr) ->
#              .func. X1(expr), X2(expr)... es la expresion de adentro. Una
#              funcion que no esta definida en el deck es Fortran del usuario
#              (funciones.for) y eso no se traduce: se dice y no se escribe.
#   INITIAL CONDITIONS   VCx = v -> ic= en el capacitor; ILx = i -> en la L
#   OUTPUTS    .print tran, en el orden del deck: Vx -> v(a,b), Ix y Jn -> la
#              corriente del sensor, P -> v(nodo del parametro)
#   RUN CONTROLS  START/STOP TIME y MAXIMUM STEP SIZE -> .tran; lo demas
#              (INTEGRATION ROUTINE, X PLOT DIMENSION) no tiene equivalente
#   RERUN DESCRIPTION   no se traduce todavia: se avisa y va la corrida maestra
#   PARAPLOT   se saltea (es de Simusol, no del circuito)
#
# Las convenciones de signo son las de SCEPTRE, verificadas con tanque contra
# el .sim de 2008 (MOTORES.md): E, a-b = v pone v en b respecto de a; J, a-b
# = i manda i de a hacia b; Vx = v(a) - v(b); Ix = corriente de a hacia b.
#
# Copyright (C) Diego Saravia <dsa@unsa.edu.ar>
# GPL version 3 o posterior.
use strict;
use warnings;
use File::Basename qw(basename dirname);
use File::Temp qw(tempdir);
use Cwd qw(abs_path);
use JSON::PP qw(decode_json);
use Getopt::Long;
use FindBin qw($RealBin);
use lib "$RealBin/../lib", "$RealBin/../share/lanzador/lib";
use MetodosMotor;

my ($ensayo, $ayuda) = (0, 0);
# EL CAMINO COORDINADO: la configuracion de las llaves la da quien conduce
# los intervalos, con el estado y la ventana de tiempo de cada uno.
my ($llaves_dadas, $desde, $hasta, $paso_dado) = (undef) x 4;
my @estado_dado;
GetOptions('n|ensayo' => \$ensayo, 'h|help' => \$ayuda,
           'llaves=s' => \$llaves_dadas, 'desde=s' => \$desde, 'hasta=s' => \$hasta,
           'paso=s' => \$paso_dado, 'estado=s' => \@estado_dado) or $ayuda = 1;
if ($ayuda or @ARGV < 1 or @ARGV > 2) {
    print "Uso: dat2cir [-n] [--llaves S1=1,S2=0] [--desde T0] [--hasta T1] [--paso P]\n";
    print "            [--estado VC1=v ...] caso.M.dsa [salida.cir]\n";
    print "  Del .dsa a un netlist de SPICE. Tambien entra un .d de SCEPTRE o un .dat.\n";
    print "  --llaves  la configuracion dada: 1 cerrada (un corto), 0 abierta. La llave\n";
    print "            es ideal y su condicion sale como una columna 0/1 por llave,\n";
    print "            detras de las salidas y de los estados.\n";
    print "  --estado  el estado inicial de un condensador (VC1) o una bobina (IL1);\n";
    print "            se puede repetir. Pisa las INITIAL CONDITIONS del deck.\n";
    exit($ayuda ? 0 : 2);
}
my %llave_dada;
if (defined $llaves_dadas) {
    for my $par (split /\s*,\s*/, $llaves_dadas) {
        $par =~ /^\s*([A-Za-z][A-Za-z0-9]*)\s*=\s*([01])\s*$/
            or die "dat2cir: --llaves va 'S1=1,S2=0', no '$par'\n";
        $llave_dada{uc $1} = $2 + 0;
    }
}
# EL TIEMPO DEL DECK NO ES EL DE ngspice CUANDO SE REANUDA UN INTERVALO:
# ngspice simula SIEMPRE desde 0 --el TSTART de .tran solo dice desde cuando
# guarda la salida-- asi que un intervalo que arranca en 0.0696 se corre con
# origen en 0, y el T (o TIME) del deck vale time + 0.0696. Sin esto el
# estado que se le da como condicion inicial se aplicaba en 0 y la tabla
# empezaba con el circuito ya evolucionado 0.0696 s (medido: VC1 salia 11.27
# donde valia 6.02).
my $TIEMPO = (defined $desde and $desde + 0 != 0) ? "(time+" . ($desde + 0) . ")" : 'time';

# la resistencia que hace de circuito abierto: la llave ideal abierta saca la
# rama, pero sacandola ngspice se queda con nodos de una sola conexion y no
# arma la matriz; 1e12 es el circuito abierto sin perder el nodo
my $ABIERTA = '1e12';
my $entrada = $ARGV[0];
-f $entrada or die "dat2cir: no existe $entrada\n";
# caso.M.dsa -> caso.M.cir (antes solo sabia quitar .d y .ds, y de un .dsa
# salia caso.M.dsa.cir, 18/11/2026)
my $salida = $ARGV[1] // do { (my $s = $entrada) =~ s/\.(dsa|dat|d)\z/.cir/i; $s eq $entrada ? "$entrada.cir" : $s };

# ---- 1. el DATO, que es por donde entran todos los formatos
# Hasta el 10/11/2026 esto parseaba el texto de un .ds. El .ds ya no existe
# (pedido del autor: "ds no existe mas, y solo sceptre y siru leen .d por
# razones de retrocompatibilidad"), y el camino bueno es el mismo que el de
# todos: el DATO. d2datdinc lleva al dato un .M.dsa --el formato-- o un .d
# --el de quien ya los tiene-- y de ese dato sale el netlist. Asi el camino
# de SPICE no depende de que formato tenia el archivo.
#
# Y el dato dice lo mismo mejor dicho que el texto: el TIPO de cada rama sin
# decodificar prefijos (CB, RB, LB, EB, JB, SB), la condicion de una llave con
# su lista de variables y sin el 'V:' pegado, y los estados marcados por el
# nombre de su derivada.
my $dat = $entrada;
my $tmpdir;
if ($entrada !~ /\.dat\z/i) {
    my $raiz = dirname(abs_path($0)) . '/../..';
    my $d2d = $ENV{D2DATDINC} // 'd2datdinc';
    $d2d = "$raiz/slex/d2datdinc/d2datdinc" if $d2d eq 'd2datdinc' and -x "$raiz/slex/d2datdinc/d2datdinc";
    my @opc;
    my $conf = $ENV{D2DATDINC_CONF} // "$raiz/slex/d2datdinc/d2datdinc.slex";
    my $bib  = $ENV{D2DATDINC_BIB}  // "$raiz/slex/d2datdinc/biblioteca";
    push @opc, '-c', $conf if -f $conf;
    push @opc, '-b', $bib  if -d $bib;
    $tmpdir = tempdir('dat2cir-XXXXXX', TMPDIR => 1, CLEANUP => 1);
    $dat = "$tmpdir/" . basename($entrada) . '.dat';
    system($d2d, @opc, $entrada, '--dat', '-o', $dat) == 0 and -s $dat
        or die "dat2cir: d2datdinc no pudo llevar $entrada al dato\n";
}
my ($g, $oi);
{
    open my $f, '<', $dat or die "dat2cir: $dat: $!\n";
    local $/;
    my $d = eval { decode_json(<$f>) } or die "dat2cir: $dat no es un dato JSON: $@\n";
    close $f;
    ($g, $oi) = ($d->{GLOBAL} || {}, $d->{OTHERINFO} || {});
}

# ---- 2. las tablas de simbolos, del dato
my $titulo = do {
    my $d = $g->{description};
    my $l = defined $d ? (split /\n/, $d)[0] : undef;
    (defined $l && $l =~ /\S/) ? $l : basename($entrada);
};
$titulo =~ s/^\s*Archivo\s+//;

# EL TIPO DE SPICE DE CADA RAMA. El dato nombra el modelo de siru (CB, RC,
# CINC...); SPICE quiere la letra del elemento. Un modelo que no este aca no
# se traduce y se dice.
my %TIPO = (RB => 'R', RC => 'R', CB => 'C', CINC => 'C', LB => 'L',
            EB => 'E', EC => 'E', JB => 'J', JC => 'J', SB => 'S');
my (%elem, @elem_orden);
{
    my $ramas = $g->{ramas} || {};
    # EL ORDEN DE LAS RAMAS es el del archivo, y en el dato lo da
    # OTHERINFO.origen_ramas (archivo y renglon), que es lo que usa el propio
    # lector para ordenarlas. Sin origen, por nombre, para que sea estable.
    my $org = $oi->{origen_ramas} || {};
    @elem_orden = sort {
        my ($oa, $ob) = ($org->{$a}, $org->{$b});
        my $r = 0;
        if ($oa && $ob) {
            $r = ($oa->{archivo} // '') cmp ($ob->{archivo} // '')
              || ($oa->{linea} // 0) <=> ($ob->{linea} // 0);
        } elsif ($oa) { $r = -1 } elsif ($ob) { $r = 1 }
        $r || $a cmp $b;
    } keys %$ramas;
    for my $n (@elem_orden) {
        my $r = $ramas->{$n};
        my $tipo = $TIPO{$r->{tipo} // ''}
            or die "dat2cir: la rama $n es de tipo $r->{tipo}, que no se traduce a SPICE\n";
        my ($a, $b) = @{$r->{nodos} || []};
        defined $a && defined $b or die "dat2cir: la rama $n no dice sus dos nodos\n";
        $elem{$n} = { tipo => $tipo, a => nodo($a), b => nodo($b), valor => $r->{valor} // '0' };
    }
}

# LOS PARAMETROS Y LOS ESTADOS. defpar son los DEFINED PARAMETERS; el que
# lleva 'der' es un estado, y su derivada se llama asi. Un parametro D<X> de
# otro parametro X es la derivada escrita como expresion, que en SPICE se
# integra con una fuente sobre un capacitor de 1 F.
my (%param, @param_orden, %deriv, %inicial_p);
{
    my $dp = $g->{defpar} || {};
    my %valor = map { $_ => (ref $dp->{$_} ? $dp->{$_}{value} : $dp->{$_}) } keys %$dp;
    # el orden: lisvar si esta, y lo que falte por nombre
    my @orden = grep { exists $valor{$_} } @{ $g->{lisvar} || [] };
    my %visto = map { $_ => 1 } @orden;
    push @orden, sort grep { !$visto{$_} } keys %valor;
    for my $n (@orden) {
        if ($n =~ /^D(.+)$/ and exists $valor{$1}) { $deriv{$1} = $valor{$n}; next }
    }
    for my $n (@orden) {
        next if $n =~ /^D(.+)$/ and exists $deriv{$1};
        if (exists $deriv{$n}) { $inicial_p{$n} = $valor{$n}; push @param_orden, $n; next }
        $param{$n} = $valor{$n};
        push @param_orden, $n;
    }
    $inicial_p{$_} //= 0 for keys %deriv;
    # LA VARIABLE DE INTEGRACION NO ES UNA CONSTANTE: el dato trae T con su
    # valor inicial, que es el comienzo de la corrida.
    if (exists $param{T}) { delete $param{T}; @param_orden = grep { $_ ne 'T' } @param_orden }
}

# LAS FUNCIONES: nombre -> [nombre, cuerpo]. El cuerpo viene con la x de la
# variable formal, como lo escribe el dato.
my (%func, @func_orden, %tabla);
{
    my $fs = $g->{funciones} || {};
    @func_orden = grep { exists $fs->{$_} } @{ $g->{lisfun} || [] };
    my %visto = map { $_ => 1 } @func_orden;
    push @func_orden, sort grep { !$visto{$_} } keys %$fs;
    for my $n (@func_orden) {
        my $f = $fs->{$n};
        my $cuerpo = ref $f eq 'ARRAY' ? $f->[1] : $f;
        next unless defined $cuerpo;
        if (ref $f eq 'ARRAY' and ref $f->[1] eq 'ARRAY') {
            # una TABLA: pares (x, y)
            $tabla{$n} = [map { [@$_] } @{$f->[1]}];
            next;
        }
        $func{$n} = { args => ['X'], expr => $cuerpo };
    }
    @func_orden = grep { $func{$_} } @func_orden;
}

# LAS TABLAS del dato (TABLE n del .d): nombre -> pares
for my $n (keys %{ $g->{tablas} || {} }) {
    my $t = $g->{tablas}{$n};
    $tabla{$n} = [map { [@$_] } @{ ref $t eq 'ARRAY' ? $t : ($t->{puntos} || []) }];
}

# LAS CONDICIONES INICIALES: en el dato son los estados, que ya salieron de
# defpar; el estado de un Condensador de siru es la CARGA y para SPICE la
# condicion inicial de un capacitor es su tension, q/C.
my %ic;
{
    my $dp = $g->{defpar} || {};
    for my $n (sort keys %$dp) {
        my $v = ref $dp->{$n} ? $dp->{$n}{value} : $dp->{$n};
        next unless defined $v;
        if ($n =~ /^Q([A-Z][A-Z0-9]*)$/ and ($elem{$1} || {})->{tipo} eq 'C') {
            my ($e, $c) = ($1, $elem{$1}{valor});
            if (es_numero($v) and es_numero($c) and $c + 0 != 0) {
                $ic{$e} //= { que => 'V', valor => ($v + 0) / ($c + 0) };
            } else {
                warn "dat2cir: $n=$v con capacidad $c: no se puede pasar la carga a"
                   . " tension, el capacitor $e arranca sin condicion inicial\n";
            }
            delete $param{$n}; @param_orden = grep { $_ ne $n } @param_orden;
        }
        elsif ($n =~ /^([VI])([A-Z][A-Z0-9]*)$/ and $elem{$2}) {
            my ($que, $e) = ($1, $2);
            $ic{$e} //= { que => $que, valor => $v }
                if ($que eq 'V' and $elem{$e}{tipo} eq 'C') or ($que eq 'I' and $elem{$e}{tipo} eq 'L');
            delete $param{$n}; @param_orden = grep { $_ ne $n } @param_orden;
        }
    }
}
# el estado dado por quien conduce los intervalos pisa lo del dato
for my $e (map { split /\s*,\s*/ } @estado_dado) {
    $e =~ /^\s*([VI])([A-Za-z][A-Za-z0-9]*)\s*=\s*(.+?)\s*$/
        or die "dat2cir: --estado va 'VC1=valor' o 'IL1=valor', no '$e'\n";
    $ic{uc $2} = { que => uc $1, valor => $3 };
}

# LAS SALIDAS: 'T:VC1,IR1' -- el eje adelante
my @outputs;
{
    my $o = $g->{outs};
    @outputs = map { uc } grep { length } map { split /\s*,\s*/ } split /:/, ($o // '');
    shift @outputs if @outputs and $outputs[0] eq 'T';
}

# LAS RESISTENCIAS DE LLAVE: data.llaves_resistivas, por nombre o GENERAL
my %ron_roff;
{
    my $lr = ($g->{data} || {})->{llaves_resistivas} || {};
    for my $n (keys %$lr) { $ron_roff{uc $n} = [@{$lr->{$n}}] }
}

# LOS CONTROLES: el dato los da como listas; el armado los quiere como texto
my %ctrl;
{
    my $c = $g->{control} || {};
    for my $k (keys %$c) {
        my $e = $c->{$k};
        # EL INTEGRA IMPLICITO NO ES ELECCION DEL USUARIO: el lector le pone
        # uno por omision a un .d sin rutina (XPO) y lo marca como implicito.
        # Tomarlo como pedido hacia que un .d sin INTEGRA fuera rechazado
        # porque SPICE no ofrece ese numero. El lanzador lo mira igual.
        next if ref $e eq 'HASH' and $e->{implicito};
        my $v = ref $e eq 'HASH' ? $e->{value} : $e;
        $ctrl{uc $k} = ref $v eq 'ARRAY' ? '[' . join(',', @$v) . ']' : $v;
    }
    # el final de la corrida: el dato lo trae como la parada T<N de
    # hequations, o como el dato TIEMPOFINAL
    for my $h (@{ $g->{hequations} || [] }) {
        my $eq = ref $h ? $h->{eq} : $h;
        next unless defined $eq and $eq =~ /^\s*T\s*<=?\s*(\S+?)\s*$/i;
        my $hasta = $1;
        $hasta = $param{uc $hasta} if !es_numero($hasta) and exists $param{uc $hasta};
        $hasta = $inicial_p{uc $1} if !es_numero($hasta) and exists $inicial_p{uc $1};
        $hasta = (ref($g->{defpar}{uc $1}) ? $g->{defpar}{uc $1}{value} : undef) // $hasta
            if !es_numero($hasta) and ($g->{defpar} || {})->{uc $1};
        $ctrl{'STOP TIME'} //= $hasta if es_numero($hasta);
    }
    $ctrl{'START TIME'} //= (ref(($g->{defpar} || {})->{T}) ? $g->{defpar}{T}{value} : undef) // 0;
}

# LOS RERUN del dato (GLOBAL.reruns), si los hay
my @reruns;
{
    my $rr = $g->{reruns};
    if (ref $rr eq 'ARRAY') {
        for my $r (@$rr) {
            my %c = (param => {}, elem => {}, ic => {}, ctrl => {});
            for my $k (keys %{ $r || {} }) {
                my $v = $r->{$k};
                if    (exists $elem{uc $k})  { $c{elem}{uc $k} = $v }
                elsif (uc($k) =~ /^([VI])([A-Z][A-Z0-9]*)$/ and $elem{$2}) { $c{ic}{$2} = $v }
                else { $c{param}{uc $k} = $v }
            }
            push @reruns, \%c;
        }
    }
}

# ---- 3. que parametros varian, y que elementos necesitan sensor de corriente
# Un parametro es constante si su expresion no mira el tiempo, ni un elemento,
# ni una tabla, ni otro parametro que varie. Se itera hasta que no cambie.
my %varia = map { $_ => 1 } keys %deriv;
my $cambio = 1;
while ($cambio) {
    $cambio = 0;
    for my $n (keys %param) {
        next if $varia{$n};
        if (depende_del_tiempo($param{$n})) { $varia{$n} = 1; $cambio = 1 }
    }
}
sub depende_del_tiempo {
    my ($e) = @_;
    my $u = uc $e;
    return 1 if $u =~ /\bTIME\b/ or $u =~ /\bXTABLE\b/ or $u =~ /\bT\d+\s*\(/;
    for my $id ($u =~ /\b([A-Z][A-Z0-9]*)\b/g) {
        return 1 if $varia{$id};
        return 1 if $id =~ /^[VI]([A-Z][A-Z0-9]*)$/ and $elem{$1};
        return 1 if $elem{$id};
    }
    return 0;
}
my %sensor;   # elementos cuya corriente se pide
my %faltan_funciones;

# ---- 4. traducir una expresion de SCEPTRE a una de ngspice
my %MATH = map { $_ => 1 } qw(EXP LOG LOG10 SIN COS TAN ASIN ACOS ATAN SINH COSH TANH SQRT ABS MIN MAX SGN INT FLOOR CEIL);
sub traducir {
    my ($e, $protegidos) = @_;
    $protegidos //= {};
    my $s = $e;
    # funciones de SCEPTRE: X1(expr) es la expresion; XTABLE(Tn, x) y Tn(x) son la tabla
    $s =~ s/\bX\d+\s*\(/(/gi;
    $s =~ s/\bXTABLE\s*\(\s*T(\d+)\s*,/pwl_T$1(/gi;
    $s =~ s/\bT(\d+)\s*\(/pwl_T$1(/gi;
    # identificadores
    my $out = '';
    while (length $s) {
        if ($s =~ s/^(\s+|\d+\.?\d*(?:[Ee][-+]?\d+)?|\.\d+(?:[Ee][-+]?\d+)?)//) { $out .= $1; next }
        if ($s =~ s/^(pwl_T\d+)//) { $out .= $1; next }
        if ($s =~ s/^([A-Za-z][A-Za-z0-9_]*)//) {
            my $id = $1; my $u = uc $id;
            if    ($protegidos->{$u})      { $out .= lc $id }
            elsif ($u eq 'TIME')           { $out .= $TIEMPO }
            elsif ($u eq 'T')              { $out .= $TIEMPO }
            elsif ($MATH{$u})              { $out .= lc $u }
            elsif ($func{$u})              { $out .= lc $u }
            elsif ($varia{$u})             { $out .= "v(np_\L$u\E)" }
            elsif (exists $param{$u})      { $out .= lc $u }
            elsif ($u =~ /^V([A-Z][A-Z0-9]*)$/ and $elem{$1}) { $out .= tension($1) }
            elsif ($u =~ /^I([A-Z][A-Z0-9]*)$/ and $elem{$1}) { $sensor{$1} = 1; $out .= "i(vs_\L$1\E)" }
            elsif ($elem{$u} and $elem{$u}{tipo} eq 'J') { $sensor{$u} = 1; $out .= "i(vs_\L$u\E)" }
            elsif ($elem{$u} and $elem{$u}{tipo} eq 'E') { $out .= tension_fuente($u) }
            elsif ($s =~ /^\s*\(/)         { $faltan_funciones{$u} = 1; $out .= lc $id }
            else                           { warn "dat2cir: no se que es '$id' en '$e'\n"; $out .= lc $id }
            next;
        }
        $s =~ s/^(.)//s; $out .= $1;
    }
    # las tablas, ahora que esta todo traducido: pwl_Tn(x) -> pwl(x, puntos)
    while ($out =~ /pwl_T(\d+)\(/) {
        my $n = $1;
        my $pos = $-[0];
        my $ini = $pos + length("pwl_T$n(");
        my ($prof, $i) = (1, $ini);
        while ($i < length $out and $prof) { my $c = substr $out, $i, 1; $prof++ if $c eq '('; $prof-- if $c eq ')'; $i++ }
        my $arg = substr $out, $ini, $i - 1 - $ini;
        my $pts = puntos_pwl($n);
        substr($out, $pos, $i - $pos) = "pwl($arg, $pts)";
    }
    return $out;
}
sub puntos_pwl {
    my ($n) = @_;
    my $t = $tabla{$n} or do { warn "dat2cir: la TABLE $n no esta en el deck\n"; return '0,0, 1,0' };
    my @p = map { [@$_] } @$t;
    # x estrictamente creciente: el escalon de SCEPTRE (dos puntos con la misma
    # x) se corre un poco, un millonesimo del rango
    my $rango = abs($p[-1][0] - $p[0][0]) || 1;
    for my $i (1 .. $#p) { $p[$i][0] = $p[$i-1][0] + $rango * 1e-6 if $p[$i][0] <= $p[$i-1][0] }
    return join ', ', map { "$_->[0],$_->[1]" } @p;
}
sub nodo { my ($n) = @_; return (uc $n eq 'GND' or $n eq '0') ? '0' : $n }
sub tension {   # Vx = v(a) - v(b)
    my ($n) = @_; my $e = $elem{$n};
    return $e->{b} eq '0' ? "v($e->{a})" : $e->{a} eq '0' ? "(-v($e->{b}))" : "v($e->{a},$e->{b})";
}
sub tension_fuente {   # E, a-b = v pone v en b respecto de a
    my ($n) = @_; my $e = $elem{$n};
    return $e->{a} eq '0' ? "v($e->{b})" : $e->{b} eq '0' ? "(-v($e->{a}))" : "v($e->{b},$e->{a})";
}
sub es_numero { $_[0] =~ /^\s*[-+]?(\d+\.?\d*|\.\d+)([Ee][-+]?\d+)?\s*$/ }

# ---- 5. armar el netlist. Una vez por corrida: la maestra y cada rerun, con
# sus valores cambiados sobre copias de las tablas (los parametros, los
# elementos, las condiciones iniciales, los controles).
my @print;
my (@salidas_nombres, @estados_nombres, @llaves_nombres);
my %carga;        # los condensadores cuya carga se imprime (QC1 en OUTPUTS)
my %base = (param => {%param}, elem => { map { $_ => {%{$elem{$_}}} } keys %elem }, ic => { map { $_ => {%{$ic{$_}}} } keys %ic }, ctrl => {%ctrl});
sub generar {
    my ($ov) = @_;
    %param = %{$base{param}}; %elem = map { $_ => {%{$base{elem}{$_}}} } keys %{$base{elem}};
    %ic = map { $_ => {%{$base{ic}{$_}}} } keys %{$base{ic}}; %ctrl = %{$base{ctrl}};
    if ($ov) {
        for my $n (keys %{$ov->{param}}) {
            if (exists $param{$n}) { $param{$n} = $ov->{param}{$n} }
            elsif (exists $deriv{$n}) { $inicial_p{$n} = $ov->{param}{$n} }
            else { warn "dat2cir: el rerun cambia $n, que no es un parametro del deck\n" }
        }
        for my $n (keys %{$ov->{elem}}) {
            if ($elem{$n}) { $elem{$n}{valor} = $ov->{elem}{$n} } else { warn "dat2cir: el rerun cambia $n, que no es un elemento\n" }
        }
        for my $n (keys %{$ov->{ic}}) { $ic{$n} = { que => 'V', valor => $ov->{ic}{$n} } }
        for my $n (keys %{$ov->{ctrl}}) { $ctrl{$n} = $ov->{ctrl}{$n} }
    }
# ---- 5. armar el netlist (primero las expresiones, para saber los sensores)
    my @cir;
    my (%valor_e, %valor_p, %valor_d);
    %sensor = (); %carga = ();
    $valor_e{$_} = traducir($elem{$_}{valor}) for @elem_orden;
    $valor_p{$_} = traducir($param{$_})       for keys %param;
    $valor_d{$_} = traducir($deriv{$_})       for keys %deriv;
    @print = ();
    # EL NOMBRE SE ANOTA CON LA COLUMNA: una salida que no se puede imprimir
    # se saltea, asi que tomar los primeros nombres de OUTPUTS corria todos
    # los demas (medido: QC1 se saltaba y la tabla llamaba QC1 a IC1)
    @salidas_nombres = ();
    my $anotar = sub { push @print, $_[1]; push @salidas_nombres, $_[0] };
    for my $o (@outputs) {
        if ($o =~ /^V([A-Z][A-Z0-9]*)$/ and $elem{$1})      { $anotar->($o, tension($1)) }
        elsif ($o =~ /^I([A-Z][A-Z0-9]*)$/ and $elem{$1})   { $sensor{$1} = 1; $anotar->($o, "i(vs_\L$1\E)") }
        # LA CARGA DE UN CONDENSADOR, q = C*V por la ley de la rama: SPICE no
        # la tiene, asi que va en una fuente de comportamiento sobre un nodo
        # propio. Es el estado del modelo Condensador de siru, y el .ds del
        # par .dsa la pide en RESULTADOS.
        elsif ($o =~ /^Q([A-Z][A-Z0-9]*)$/ and $elem{$1} and $elem{$1}{tipo} eq 'C') {
            my $n = $1;
            $carga{$n} = 1;
            $anotar->($o, "v(nq_\L$n\E)");
        }
        elsif ($elem{$o} and $elem{$o}{tipo} eq 'J')        { $sensor{$o} = 1; $anotar->($o, "i(vs_\L$o\E)") }
        elsif ($elem{$o} and $elem{$o}{tipo} eq 'E')        { $anotar->($o, tension_fuente($o)) }
        elsif ($varia{$o})                                  { $anotar->($o, "v(np_\L$o\E)") }
        elsif (exists $param{$o})                           { warn "dat2cir: $o es una constante, no se imprime\n" }
        else { warn "dat2cir: no se que es '$o' en OUTPUTS\n" }
    }
    # EL CONTRATO DEL CAMINO COORDINADO: detras de las salidas del deck van
    # los ESTADOS --la tension de cada condensador y la corriente de cada
    # bobina, que es con lo que se reanuda el intervalo siguiente-- y despues
    # una columna 0/1 por LLAVE con el valor de su condicion. El netlist lo
    # dice en comentarios, asi que quien conduce no cuenta columnas a mano.
    @estados_nombres = (); @llaves_nombres = ();
    if (defined $llaves_dadas) {
        for my $n (@elem_orden) {
            if ($elem{$n}{tipo} eq 'C') { push @estados_nombres, "V$n"; push @print, tension($n) }
            elsif ($elem{$n}{tipo} eq 'L') {
                $sensor{$n} = 1; push @estados_nombres, "I$n"; push @print, "i(vs_\L$n\E)";
            }
        }
        for my $n (@elem_orden) {
            next unless $elem{$n}{tipo} eq 'S';
            push @llaves_nombres, $n; push @print, "v(nw_\L$n\E)";
        }
    }
    my %func_exprs;
    for my $f (@func_orden) {
        my %prot = map { $_ => 1 } @{$func{$f}{args}};
        $func_exprs{$f} = traducir($func{$f}{expr}, \%prot);
    }
    if (%faltan_funciones) {
        print STDERR "dat2cir: $entrada usa " . join(', ', sort keys %faltan_funciones)
            . ", que no esta definida en FUNCTIONS: es Fortran del usuario (funciones.for) y eso no se traduce a SPICE\n";
        exit 3;
    }
    # los sensores se deciden en la traduccion de arriba; las variaciones de las
    # expresiones (reruns) pueden pedir otros, asi que el conjunto se junta
    
    push @cir, "$titulo  (dat2cir, de " . basename($entrada) . ")";
    push @cir, "* traducido por dat2cir (lanzador) desde el dato del modelo";
    for my $f (@func_orden) {
        push @cir, ".func \L$f\E(" . join(',', map { lc } @{$func{$f}{args}}) . ") {$func_exprs{$f}}";
    }
    for my $p (@param_orden) {
        next if $varia{$p} or exists $deriv{$p} or not exists $param{$p};
        push @cir, ".param \L$p\E={$valor_p{$p}}";
    }
    for my $p (@param_orden) {
        next unless $varia{$p};
        if (exists $deriv{$p}) {
            # la integral: dv/dt = I/C con C = 1 F
            push @cir, "Bd_\L$p\E 0 np_\L$p\E I={$valor_d{$p}}";
            push @cir, "Ci_\L$p\E np_\L$p\E 0 1 ic=$inicial_p{$p}";
        } else {
            push @cir, "Bp_\L$p\E np_\L$p\E 0 V={$valor_p{$p}}";
        }
    }
    for my $n (@elem_orden) {
        my $e = $elem{$n}; my ($a, $b, $v) = ($e->{a}, $e->{b}, $valor_e{$n});
        my $ln = lc $n;
        if ($sensor{$n}) {
            # la corriente de a hacia b: una fuente de 0 V entre a y el elemento
            my $as = "${a}_s_$ln";
            push @cir, "Vs_$ln $a $as DC 0";
            $a = $as;
        }
        my $ic = $ic{$n} ? " ic=$ic{$n}{valor}" : '';
        my $num = es_numero($v);
        # R, C y L: el nombre de SPICE empieza con la letra del tipo, y los de
        # SCEPTRE ya empiezan asi (R5, CA, L23): van tal cual, en minuscula
        if ($e->{tipo} eq 'S') {
            # la llave, TOMADA COMO RESISTIVA (pedido del autor, 09/11/2026):
            # la condicion dentro de la ecuacion, r = cond ? RON : ROFF, igual
            # que libdin y que la exportacion FLLAVS a SCEPTRE. Sin RON/ROFF
            # declarados (DATA llaves_resistivas) no hay traduccion: para ir
            # directo a SPICE ninguna llave puede quedar ideal.
            if (defined $llaves_dadas) {
                # LA CONFIGURACION DADA: la llave es ideal y no lleva su
                # condicion adentro. Cerrada, un corto exacto --una fuente de
                # 0 V, que ademas da su corriente--; abierta, el circuito
                # abierto. Quien conduce los intervalos decide cuando cambia.
                defined $llave_dada{$n}
                    or die "dat2cir: --llaves no dice el estado de la llave $n\n";
                push @cir, $llave_dada{$n} ? "Vsw_$ln $a $b DC 0"
                                           : "rsw_$ln $a $b $ABIERTA";
            } else {
                my $rr = $ron_roff{$n} // $ron_roff{GENERAL}
                    or die "dat2cir: la llave $n no tiene RON/ROFF: para SPICE las llaves"
                         . " van resistivas (DATA {'llaves_resistivas'})\n";
                push @cir, "r$ln $a $b r={($v) ? $rr->[0] : $rr->[1]}";
            }
        }
        elsif ($e->{tipo} eq 'R') { push @cir, "$ln $a $b " . ($num ? $v : "r={$v}") }
        elsif ($e->{tipo} eq 'C') { push @cir, "$ln $a $b " . ($num ? $v : "{$v}") . $ic }
        elsif ($e->{tipo} eq 'L') { push @cir, "$ln $a $b " . ($num ? $v : "{$v}") . $ic }
        elsif ($e->{tipo} eq 'E') { push @cir, $num ? "Ve_$ln $b $a DC $v" : "Be_$ln $b $a V={$v}" }
        elsif ($e->{tipo} eq 'J') { push @cir, "Bj_$ln $a $b I={$v}" }
        else { warn "dat2cir: el elemento $n es de tipo $e->{tipo}, que no se traduce\n" }
    }
    # LA CONDICION DE CADA LLAVE, APARTE: una fuente de comportamiento sobre
    # un nodo propio que vale 1 si la condicion se cumple y 0 si no. No
    # interviene en el circuito; es lo que mira quien conduce los intervalos.
    for my $n (@llaves_nombres) {
        push @cir, "Bw_\L$n\E nw_\L$n\E 0 V={($valor_e{$n}) ? 1 : 0}";
    }
    # la carga de un condensador: q = C*V, con la capacidad que el deck da
    for my $n (sort keys %carga) {
        push @cir, "Bq_\L$n\E nq_\L$n\E 0 V={($valor_e{$n})*(" . tension($n) . ")}";
    }
    # LA VENTANA DEL INTERVALO, si la dan (antes de deducir el final de la
    # parada: el camino coordinado corre un intervalo por vez)
    $ctrl{'START TIME'} = $desde if defined $desde;
    $ctrl{'STOP TIME'}  = $hasta if defined $hasta;
    # el STOP TIME ya salio de la parada del dato (hequations), en la
    # seccion 2: aca solo queda lo que lo pise por --hasta
    if (!defined $ctrl{'MAXIMUM STEP SIZE'} and defined $ctrl{SIRU_PASO}
        and $ctrl{SIRU_PASO} =~ /\A\s*\[\s*([^,\]\s]+)\s*\]\s*\z/) {
        $ctrl{'MAXIMUM STEP SIZE'} = $1;
    }
    my ($t0, $t1) = ($ctrl{'START TIME'} // 0, $ctrl{'STOP TIME'});
    defined $t1 or die "dat2cir: el deck no tiene STOP TIME (ni una parada T<N en CONTROL_EQUATIONS)\n";
    # .tran TSTEP TSTOP TSTART TMAX: TSTEP es cada cuanto imprime (unos 300 puntos,
    # como un .sim de SCEPTRE) y TMAX el paso maximo de integracion. TMAX importa:
    # con 1/300 del tiempo, planeta1 --una orbita de periodo 0,024 en 0,1 s-- daba
    # otra cosa; con 1/10000 coincide con una referencia RK4 de paso 2e-6 en
    # cuatro cifras (y el SCEPTRE de 2008 es el que esta lejos). Si el deck trae
    # MAXIMUM STEP SIZE, ese manda.
    my $span = $t1 - $t0;
    # EL PASO DE LA MALLA, si lo dan: con un intervalo por corrida, 1/300 del
    # intervalo seria otra malla en cada uno. Quien conduce pasa la malla de
    # toda la corrida, asi que los puntos caen siempre en los mismos tiempos.
    my $paso = defined $paso_dado ? $paso_dado + 0 : $span / 300;
    die "dat2cir: --paso tiene que ser positivo, no $paso_dado\n" if $paso <= 0;
    # EN EL CAMINO COORDINADO el paso maximo es el de la malla: sin interp
    # cada paso aceptado es un renglon, y con 1/10000 del intervalo son
    # decenas de miles por intervalo. Es ademas el paso con que se evaluan
    # las condiciones de las llaves, como en siru.
    my $tmax = $ctrl{'MAXIMUM STEP SIZE'}
            // (defined $llaves_dadas ? $paso : $span / 10000);
    # TMAX nunca mayor que TSTEP: con pasos mas grandes que la grilla de
    # salida, el interp de ngspice devuelve una tabla corrupta (45 puntos,
    # tiempos corridos; medido con SIRU_PASO=0.05 y TSTEP=1/150)
    $tmax = $paso if $tmax > $paso;
    # con --desde el intervalo corre con origen en 0 y dura $span: quien
    # conduce le suma el comienzo a los tiempos de la tabla
    push @cir, defined $desde ? ".tran $paso $span 0 $tmax uic"
                              : ".tran $paso $t1 $t0 $tmax uic";
    # sin esto ngspice imprime cada paso aceptado (10007 renglones en tanque);
    # con interp, en la grilla de TSTEP, como SCEPTRE
    # Nunca omitir un INTEGRA explícito. La misma tabla que consulta el
    # lanzador rige también cuando se usa dat2cir directamente.
    if (exists $ctrl{INTEGRA}) {
        my $v=$ctrl{INTEGRA};
        $v =~ /\A\s*\[\s*(\d+)\s*\]\s*\z/
            or die "dat2cir: INTEGRA requiere un único número para Spice\n";
        my $metodo=MetodosMotor->resolver('spice',$1);
        push @cir, '.options method='.$metodo->{nombre};
    }
    # SIN interp EN EL CAMINO COORDINADO: interp reescribe la tabla sobre la
    # malla interpolando, y la columna 0/1 de una llave interpolada sale en
    # 0.41 justo en el instante en que conmuta (medido con T>=1 y paso 0.05),
    # o sea que el instante se detectaria un paso tarde. Sin interp cada
    # renglon es un paso que ngspice acepto, con su valor exacto; la malla la
    # arma quien conduce los intervalos, que es el que sabe donde cortan.
    push @cir, ".options interp" unless defined $llaves_dadas;
    push @cir, ".print tran " . join(' ', @print) if @print;
    if (defined $llaves_dadas) {
        push @cir, "* dat2cir columnas: salidas=" . scalar(@salidas_nombres)
                 . " estados=" . scalar(@estados_nombres)
                 . " llaves=" . scalar(@llaves_nombres);
        push @cir, "* dat2cir salidas: @salidas_nombres" if @salidas_nombres;
        push @cir, "* dat2cir estados: @estados_nombres" if @estados_nombres;
        push @cir, "* dat2cir llaves: @llaves_nombres"   if @llaves_nombres;
    }
    push @cir, ".end";
    return @cir;
}
my @cir = generar(undef);
my @cir_reruns = map { [ generar($_) ] } @reruns;
if ($ensayo) {
    print "$_\n" for @cir;
    for my $r (0 .. $#cir_reruns) { print "* ---- rerun " . ($r+1) . "\n"; print "$_\n" for @{$cir_reruns[$r]} }
    exit 0;
}
open my $out, '>', $salida or die "dat2cir: no puedo escribir $salida: $!\n";
print {$out} "$_\n" for @cir;
close $out;
my @archivos_rerun;
for my $r (0 .. $#cir_reruns) {
    (my $sr = $salida) =~ s/(\.cir)?\z/_rerun@{[$r+1]}.cir/;
    open my $o, '>', $sr or die "dat2cir: no puedo escribir $sr: $!\n";
    print {$o} "$_\n" for @{$cir_reruns[$r]};
    close $o; push @archivos_rerun, $sr;
}
print " escrito $salida (" . scalar(@elem_orden) . " elementos, " . scalar(@print) . " salidas"
    . (%deriv ? ", " . scalar(keys %deriv) . " integrales" : '')
    . (@archivos_rerun ? "; y " . scalar(@archivos_rerun) . " rerun: @archivos_rerun" : '') . ")\n";
exit 0;
