#!/bin/sh
# probar-vuelta: la vara del escritor de .dsa (escribir.c). Para cada deck,
# el .d se regenera por los DOS caminos y los dos tienen que dar lo mismo:
#
#   .d -> dato -> .d                 (d2datdinc --d)            el patron
#   .d -> dato -> .dsa -> dato -> .d (--dsa y despues --d)      la vuelta
#
# Si la vuelta da el mismo .d, el .dsa que escribio slex lleva todo lo que el
# deck tenia. Lo que difiera se informa con su diff.
#
#   [CORPUS=...] [SOLO="a01 a02"] [ESPERA=120] sh slex/dsa/probar-vuelta [ARCHIVO.d ...]
#
# Sin archivos toma los pares CASO.M.d + CASO.DU.d de CORPUS (por omision el
# corpus de sceptresimusol, al lado del arbol de slex).
set -e
AQUI=`cd "\`dirname "$0"\`" && pwd`
SLEX=`dirname "$AQUI"`
D2D=${D2DATDINC:-$SLEX/d2datdinc/d2datdinc}
CONF=${D2DATDINC_CONF:-$SLEX/d2datdinc/d2datdinc.slex}
BIB=${D2DATDINC_BIB:-$SLEX/d2datdinc/biblioteca}
CORPUS=${CORPUS:-$SLEX/../sceptresimusol/corpus}
test -x "$D2D" || { echo "probar-vuelta: falta $D2D (make -C slex)"; exit 77; }
T=`mktemp -d "${TMPDIR:-/tmp}/probar-vuelta.XXXXXX"`
test -n "${GUARDAR:-}" || trap 'cd /; rm -rf "$T"' 0 1 2 3 15
# Con un limite de tiempo: paralelo1200t, el deck de 1200 ramas, se queda
# horas leyendo el .dsa de vuelta y antes se llevaba la corrida entera por
# delante. Lo que no termina sale como "sin poder" y la vara sigue.
ESPERA=${ESPERA:-120}
corre () { timeout "$ESPERA" "$D2D" -c "$CONF" -b "$BIB" "$@"; }

decks=""
if [ $# -gt 0 ]; then decks="$*"
else
  for m in "$CORPUS"/*.M.d; do
    test -f "$m" || continue
    c=`basename "$m" .M.d`
    if [ -n "${SOLO:-}" ]; then
      ok=0; for s in $SOLO; do [ "$s" = "$c" ] && ok=1; done
      [ $ok = 1 ] || continue
    fi
    cat "$m" "$CORPUS/$c.DU.d" > "$T/$c.d" 2>/dev/null || continue
    decks="$decks $T/$c.d"
  done
fi

igual=0; distinto=0; nose=0; afuera=0
for deck in $decks; do
  c=`basename "$deck" .d`
  d="$T/$c"; mkdir -p "$d"; cp "$deck" "$d/$c.d"
  # El codigo de salida no alcanza para descartar un deck: d2datdinc sale
  # con 2 cuando algo quedo sin traducir y de todos modos escribe. Lo que
  # importa para la vara es que el archivo este: si los dos caminos pierden
  # lo mismo, la comparacion sigue diciendo si el .dsa llevo el resto.
  ( cd "$d" && corre "$c.d" --d -o patron.d >salida1 2>&1 ) || :
  if [ ! -s "$d/patron.d" ]; then
    # sin patron no hay vara: el camino .d solo ya falla, y eso no es del
    # escritor del .dsa (roto, vacio y variserr son decks invalidos a
    # proposito, para cubrir las rutinas de error de SCEPTRE)
    echo "probar-vuelta: $c: fuera de la vara: el camino .d solo ya falla"
    afuera=`expr $afuera + 1`
    sed -n '1,3p' "$d/salida1"; continue
  fi
  ( cd "$d" && corre "$c.d" --dsa par >salida2 2>&1 ) || :
  if [ ! -s "$d/par.M.dsa" ]; then
    echo "probar-vuelta: $c: el .dsa no se pudo escribir"; nose=`expr $nose + 1`
    sed -n '1,3p' "$d/salida2"; continue
  fi
  ( cd "$d" && corre par.M.dsa --d -o vuelta.d >salida3 2>&1 ) || :
  if [ ! -s "$d/vuelta.d" ]; then
    echo "probar-vuelta: $c: el .dsa no se pudo volver a leer"; nose=`expr $nose + 1`
    sed -n '1,3p' "$d/salida3"; continue
  fi
  grep -v '^;' "$d/patron.d" > "$d/patron.limpio" || :
  grep -v '^;' "$d/vuelta.d" > "$d/vuelta.limpio" || :
  if diff -q "$d/patron.limpio" "$d/vuelta.limpio" >/dev/null 2>&1; then
    igual=`expr $igual + 1`
  else
    distinto=`expr $distinto + 1`
    echo "probar-vuelta: DISTINTO $c"
    diff "$d/patron.limpio" "$d/vuelta.limpio" | sed -n '1,6p' | sed 's/^/    /'
  fi
done
echo "probar-vuelta: $igual iguales, $distinto distintos, $nose sin poder, $afuera fuera de la vara"
test "$distinto" = 0 -a "$nose" = 0
