#!/bin/sh
# pasar-a-dsa: convertir los .d del arbol a .dsa con slex, comprobando cada
# uno. Es el paso 3 del camino que pidio Diego: en el corpus de sceptre solo
# quedan .dsa --corto o largo--, y SCEPTRE no espera mas un .d (si bien nada
# se hace para impedirselo).
#
#   [ARBOL=...] [SOLO="a01 a02"] tools/pasar-a-dsa [DIRECTORIO ...]
#
# Sin directorios toma corpus y docs/manual-es, sin viejos.
#
# QUE ESCRIBE
#   CASO.M.d + CASO.DU.d  ->  CASO.M.dsa + CASO.DU.dsa   (el par, la forma larga)
#   NOMBRE.d              ->  NOMBRE.dsa                (la forma corta)
#
# COMO COMPRUEBA CADA UNO: la misma vara de slex/dsa/probar-vuelta. El .d se
# regenera por los dos caminos y los dos tienen que dar lo mismo:
#
#   .d -> dato -> .d                 el patron
#   .d -> .dsa -> dato -> .d         la vuelta
#
# Si la vuelta da otro .d, el .dsa no lleva todo lo que el deck tenia: el .dsa
# NO se escribe y el deck se informa. Los decks invalidos a proposito (roto,
# vacio, variserr: cubren las rutinas de error de SCEPTRE) no tienen patron
# --el camino .d solo ya falla-- y quedan "fuera de la vara": su .dsa tampoco
# se escribe, porque no hay con que comprobarlo.
#
# No borra ningun .d ni toca el SVN: dice al final que agregar.
set -e
AQUI=`cd "\`dirname "$0"\`" && pwd`
ARBOL_FUENTE=`dirname "$AQUI"`
SLEX=${SLEX:-$ARBOL_FUENTE/../slex}
D2D=${D2DATDINC:-$SLEX/d2datdinc/d2datdinc}
CONF=${D2DATDINC_CONF:-$SLEX/d2datdinc/d2datdinc.slex}
BIB=${D2DATDINC_BIB:-$SLEX/d2datdinc/biblioteca}
ESPERA=${ESPERA:-1800}
test -x "$D2D" || { echo "pasar-a-dsa: falta $D2D (make -C slex)"; exit 77; }

T=`mktemp -d "${TMPDIR:-/tmp}/pasar-a-dsa.XXXXXX"`
test -n "${GUARDAR:-}" || trap 'cd /; rm -rf "$T"' 0 1 2 3 15
corre () { timeout "$ESPERA" "$D2D" -c "$CONF" -b "$BIB" --motor sceptre "$@"; }

dirs=${*:-"$ARBOL_FUENTE/corpus $ARBOL_FUENTE/docs/manual-es"}
decks=""
for dir in $dirs; do
  test -d "$dir" || continue
  for f in `find "$dir" -name '*.d' -not -path '*/viejos/*' | sort`; do
    case "$f" in *.DU.d) continue;; esac   # el DU va con su M
    decks="$decks $f"
  done
done

hechos=0; mal=0; afuera=0; salteados=0
nuevos="$T/nuevos"
: > "$nuevos"
for d in $decks; do
  base=`basename "$d" .d`
  caso=`echo "$base" | sed 's/\.M$//'`
  if [ -n "${SOLO:-}" ]; then
    ok=0; for s in $SOLO; do [ "$s" = "$caso" ] && ok=1; done
    [ $ok = 1 ] || continue
  fi
  dir=`dirname "$d"`
  par=0
  case "$base" in *.M) par=1;; esac
  # NO PISAR UN .dsa QUE YA ESTA: puede ser otro caso con el mismo nombre
  # escrito a mano --calculaohm.M.dsa es el modelo de la ley de Ohm de
  # pasos/FUNCION-CALCULA, no la traduccion de calculaohm.d--
  ya=""
  if [ $par = 1 ]; then test -f "$dir/$caso.M.dsa" && ya="$dir/$caso.M.dsa"
  else test -f "$dir/$caso.dsa" && ya="$dir/$caso.dsa"
  fi
  if [ -n "$ya" ]; then
    echo "pasar-a-dsa: $caso: ya hay un .dsa ($ya): no se convierte, mirarlo a mano"
    salteados=`expr $salteados + 1`; continue
  fi
  w="$T/$caso"; rm -rf "$w"; mkdir -p "$w"
  # el deck entero: el par se junta para leerlo, como hace la vara
  if [ $par = 1 ]; then cat "$d" "$dir/$caso.DU.d" > "$w/$caso.d" 2>/dev/null || cp "$d" "$w/$caso.d"
  else cp "$d" "$w/$caso.d"
  fi
  ( cd "$w" && corre "$caso.d" --d -o patron.d >salida1 2>&1 ) || :
  if [ ! -s "$w/patron.d" ]; then
    echo "pasar-a-dsa: $caso: FUERA DE LA VARA, el camino .d solo ya falla: no se convierte"
    sed -n '1,2p' "$w/salida1" | sed 's/^/    /'
    afuera=`expr $afuera + 1`; continue
  fi
  ( cd "$w" && corre "$caso.d" --dsa par >salida2 2>&1 ) || :
  if [ ! -s "$w/par.M.dsa" ]; then
    echo "pasar-a-dsa: $caso: el .dsa no se pudo escribir: no se convierte"
    grep -v '^d2datdinc: .*traducido\|^d2datdinc: .* a par' "$w/salida2" | sed -n '1,2p' | sed 's/^/    /'
    mal=`expr $mal + 1`; continue
  fi
  ( cd "$w" && corre par.M.dsa --d -o vuelta.d >salida3 2>&1 ) || :
  if [ ! -s "$w/vuelta.d" ]; then
    echo "pasar-a-dsa: $caso: el .dsa no se pudo volver a leer: no se convierte"
    sed -n '1,2p' "$w/salida3" | sed 's/^/    /'
    mal=`expr $mal + 1`; continue
  fi
  grep -v '^;' "$w/patron.d" > "$w/patron.limpio" || :
  grep -v '^;' "$w/vuelta.d" > "$w/vuelta.limpio" || :
  if ! diff -q "$w/patron.limpio" "$w/vuelta.limpio" >/dev/null 2>&1; then
    echo "pasar-a-dsa: $caso: la vuelta no da el mismo .d: no se convierte"
    diff "$w/patron.limpio" "$w/vuelta.limpio" | sed -n '1,6p' | sed 's/^/    /'
    mal=`expr $mal + 1`; continue
  fi
  # comprobado: ahora si se escribe al lado del .d
  if [ $par = 1 ]; then
    cp "$w/par.M.dsa" "$dir/$caso.M.dsa"
    cp "$w/par.DU.dsa" "$dir/$caso.DU.dsa"
    echo "$dir/$caso.M.dsa" >> "$nuevos"
    echo "$dir/$caso.DU.dsa" >> "$nuevos"
  else
    ( cd "$w" && corre "$caso.d" --dsa - > "$w/corto.dsa" 2>/dev/null ) || :
    if [ ! -s "$w/corto.dsa" ]; then
      echo "pasar-a-dsa: $caso: la forma corta no se pudo escribir: no se convierte"
      mal=`expr $mal + 1`; continue
    fi
    cp "$w/corto.dsa" "$dir/$caso.dsa"
    echo "$dir/$caso.dsa" >> "$nuevos"
  fi
  hechos=`expr $hechos + 1`
done

echo "pasar-a-dsa: $hechos convertidos y comprobados, $mal sin convertir, $afuera fuera de la vara, $salteados ya tenian .dsa"
if [ -s "$nuevos" ]; then
  echo "pasar-a-dsa: para agregarlos al SVN:"
  echo "    svn add `tr '\n' ' ' < "$nuevos"`" | fold -s -w 78
fi
test "$mal" = 0
