#!/bin/bash
# hacer-patron ARBOL CASO X
# Corre CASO.d con ARBOL/bin/sc1 (cuasioriginal o nuevo) y deja:
#   CASO.sim           la traduccion de tabular del CASO.dirac
#                      (todas las corridas, 17 cifras)
#   CASO.casoX.patron  el .ls2 (tablas impresas y mensajes) sin fechas
#                      ni tiempos de CPU, mas el .sim
# Comparar entre pasos con diff.
# Ej.: ./hacer-patron cuasioriginal a01 0 ; diff a01.caso1.patron a01.caso0.patron
#
# Casos especiales:
# - Si existe CASO.base (contiene el nombre de otro caso), primero se corre
#   ese caso base y se restauran sus pgmsave.for y datasave.dat, que es lo
#   que esperan los decks de continuacion (CONTINUE y RE-OUTPUT).
# - Un caso de ERROR a proposito (la fase 1 rechaza el deck y no hay .ls2):
#   el patron es el .ls1 (los mensajes de error), filtrado igual.

set -e
ARBOL=$1; CASO=$2; X=$3
test -n "$X" || { echo "uso: hacer-patron ARBOL CASO X"; exit 2; }
AQUI=$(dirname "$(readlink -f "$0")")
cd "$AQUI"
# EL ARBOL PUEDE SER UNA RUTA ABSOLUTA (08/11/2026). Antes era siempre
# relativa al directorio del paquete --'cuasioriginal' o 'nuevo', que eran dos
# arboles hermanos con bin/ y lib/ adentro, los del build artesanal--. Con un
# solo build, el de automake, lo que hay es una INSTALACION (make install con
# un DESTDIR alcanza), y esa puede estar en cualquier parte:
#    ./hacer-patron /tmp/destino/usr/local vacio 0
# Una ruta relativa sigue significando lo de antes.
case "$ARBOL" in
  /*) RAIZ=$ARBOL ;;
  *)  RAIZ=$AQUI/../$ARBOL ;;
esac

# El corpus tiene que dar lo mismo en cualquier maquina: que una
# configuracion de usuario (~/.config/sceptre/sceptre.conf, que sc1 lee desde
# el paso 6) no cambie los patrones.
export SCEPTRE_NO_CONF=1

# AVISO SI LOS BINARIOS ESTAN DESPAREJOS. hacer-patron corre bin/sc1, que
# busca en bin/ y lib/ ANTES que en el arbol, asi que un 'make -C sceptreM' o
# 'make -C sceptreDU' sin sincronizar deja midiendo con el ejecutable anterior.
# Paso: lib/libsceptreDU.a de las 08:37 contra sceptreDU/libsceptreDU.a de las 13:23, y una traza
# puesta en setdat no aparecia en ninguna salida. Se arregla con
# 'make -C ARBOL sync' (o make install).
for par in "sceptreM/sceptreM:bin/sceptreM" "sceptreDU/libsceptreDU.a:lib/libsceptreDU.a" "sceptreDU/sceptreDU.o:lib/sceptreDU.o"; do
   enarbol="$RAIZ/${par%%:*}"; instalado="$RAIZ/${par##*:}"
   test -f "$enarbol" -a -f "$instalado" || continue
   if test "$enarbol" -nt "$instalado"; then
      echo "hacer-patron: OJO, $instalado es mas viejo que $enarbol" >&2
      echo "hacer-patron: sc1 usa el instalado; correr 'make -C $AQUI/../$ARBOL sync'" >&2
   fi
done

# EL RENGLON DE SALIDA de las dos fases trae la hora y el numero de linea del
# fuente, que cambian en cada corrida y cada vez que el codigo se mueve: el
# cuarto sed los saca y deja el codigo, el archivo, la rutina y el mensaje,
# que son los que importan. Tiene que ser EL MISMO filtro que
# nuevo/tests/check-corpus.sh (paso 10, ver pasos/SALIDAS).
filtrar() {
   sed -e 's/compiled:.*$//' \
       -e 's/[0-9][0-9]\.[0-9][0-9]\.[0-9][0-9] - [0-9][0-9]:[0-9][0-9]:[0-9][0-9]//' \
       -e '/computer (elapsed) time/d' \
       -e '/solution (CPU) time/d' \
       -e 's/\(SCEPTRE: SALIDA . [0-9]*\) . [0-9][0-9]:[0-9][0-9]:[0-9][0-9] . \([A-Za-z0-9_]*[.]f90\):[0-9]*/\1 | \2/' \
       -e '/programa generado cargado de/d' \
       -e '/CPU time used/d' \
       "$1"
}

# EL CORPUS ESTA DIVIDIDO (03/11/2026, dividir-md.py): CASO.M.d + CASO.DU.d.
# El .d junto se arma por cat para la corrida y, si lo armamos aca, se borra
# al final: el corpus queda dividido.
JUNTADO=""
junta () {
   if [ ! -f "$1.d" ] && [ -f "$1.M.d" ]; then
      cat "$1.M.d" "$1.DU.d" > "$1.d"; JUNTADO="$JUNTADO $1.d"
   fi
}

CONTINUAR=
if [ -f "$CASO.base" ]; then
   BASE=$(cat "$CASO.base")
   junta "$BASE"
   "$RAIZ/bin/sc1" "$BASE" </dev/null >"$BASE.corrida" 2>&1 || true
   # lo que CNTNU/XOTPR esperan encontrar de la corrida anterior:
   cp "${BASE}_pgmsave.f" pgmsave.for
   # el estado FINAL de la base (sc1 lo deja como CASO.datasave-final desde
   # el paso 9; CASO.datasave es el de la fase 1, el que repite la corrida)
   cp "${BASE}.datasave-final" datasave.dat
   # los datos de ploteo (defecto 21): RE-OUTPUT los relee
   test -f "${BASE}.plotsave" && cp "${BASE}.plotsave" plotsave.dat
   # sin -continuar, sc1 arranca borrando justo lo restaurado (defecto 22)
   CONTINUAR=-continuar
fi

# EL LISTADO SE ABRE EN APPEND, asi que si queda uno de una corrida anterior
# la nueva se le agrega atras y el patron sale de DOS corridas: paso con
# rcgrande, que daba 22 mensajes cuando la corrida nueva daba 1. Un patron
# tiene que salir de UNA corrida, asi que se arranca de cero.
rm -f "$CASO.log" "$CASO.ls1" "$CASO.ls2"

# CASO.entorno (21/10/2026): si existe, sus renglones VAR=VALOR van al
# entorno de las dos fases SOLO de ese caso. Lo usa cuelga.d, el ejemplo que
# se cuelga a proposito, con SCEPTRE_SIN_AVANCE=5: sin eso el corpus esperaria
# el corte de siempre en cada modo.
ENTORNO=""; test -f "$CASO.entorno" && ENTORNO=`grep -v '^ *#' "$CASO.entorno"`
junta "$CASO"
env $ENTORNO "$RAIZ/bin/sc1" $CONTINUAR "$CASO" </dev/null >"$CASO.corrida" 2>&1 || true

# EL LISTADO AHORA ES UNO SOLO POR CASO (paso 10): las dos fases abren el
# archivo que dice SCEPTRE_LOG al final de lo que ya tenga, y sc1 les pasa el
# mismo CASO.log a las dos. Los patrones siguen siendo uno POR FASE, asi que
# aca se corta el .log por la cabecera que cada fase imprime al arrancar
# --'SC1 - SCEPTREM' y 'SC1 - SCEPTREDU'--. Antes los .ls1 y .ls2 los dejaba sc1
# moviendo el sceptre.lis entre fase y fase.
if [ -f "$CASO.log" ]; then
   awk -v f1="$CASO.ls1" -v f2="$CASO.ls2" '
      /SC1 - SCEPTREM/ { fase = f1 }
      /SC1 - SCEPTREDU/ { fase = f2 }
      { if (fase != "") print > fase }
   ' "$CASO.log"
fi
test -f "$CASO.ls1" || : > "$CASO.ls1"
test -f "$CASO.ls2" || : > "$CASO.ls2"

# el .ls2 de una simulacion BORRADA trae solo el renglon de version: no es
# una corrida. Y los casos de solo-CI (RUN INITIAL CONDITIONS ONLY) tienen
# .ls2 con las tablas pero NO dejan .dirac: el patron es su .ls2, sin .sim.
if [ "$(wc -l < "$CASO.ls2" 2>/dev/null || echo 0)" -gt 2 ]; then
   filtrar "$CASO.ls2" > "$CASO.caso$X.patron"
   if [ -f "$CASO.dirac" ]; then
      interpola --exportar-simul "$CASO.dirac" > "$CASO.sim"
      echo "==== $CASO.sim (tabular, todas las corridas) ====" >> "$CASO.caso$X.patron"
      cat "$CASO.sim" >> "$CASO.caso$X.patron"
   fi
elif [ -s "$CASO.ls1" ]; then
   # sin .dirac no hubo corrida de datos (caso de ERROR a proposito, p.ej.
   # SIMULATION DELETED): el patron es el .ls1, mas el .ls2 si quedo alguno
   echo "==== caso sin corrida de datos: el patron es el .ls1 ====" > "$CASO.caso$X.patron"
   filtrar "$CASO.ls1" >> "$CASO.caso$X.patron"
   if [ -s "$CASO.ls2" ]; then
      echo "==== y el .ls2 que quedo ====" >> "$CASO.caso$X.patron"
      filtrar "$CASO.ls2" >> "$CASO.caso$X.patron"
   fi
else
   echo "hacer-patron: $CASO no dejo ni .ls2 ni .ls1" >&2
   exit 1
fi
if [ -n "$JUNTADO" ]; then rm -f $JUNTADO; fi
echo "$CASO.caso$X.patron listo"
