#!/usr/bin/env python3
"""probar-maxima: la prueba del motor maxima del lanzador (MOTORES.md).

    pruebas/probar-maxima [--ver]

Corre `lanzador --motor maxima` sobre unos casos del corpus, cada uno en un
directorio temporal nuevo (no toca el corpus), y comprueba las dos cosas que
el motor promete:

  - que diga bien si hay o no solucion en forma cerrada, con el estado de
    MOTORES.md (0 la hay, 3 no la hay o la entrada no va con este motor);
  - que la formula evaluada coincida con la solucion exacta independiente que
    ya tiene el corpus (NOMBRE.exacta, de siru/corpus/exactas, que no pasa ni
    por siru ni por SCEPTRE ni por Maxima), en los tiempos de esa exacta;
  - y, en los circuitos con llaves, que el horario de las configuraciones sea
    el esperado --la condicion se evalua al comenzar cada paso de la malla,
    como en siru, asi que la conmutacion cae en un punto de la malla: con
    (T>1) y paso 1/50, el paso que empieza en T=1 todavia esta abierto y la
    llave cierra en 51/50-- y que en cada conmutacion con lazo o corte haya
    dos filas, la de antes y la de despues, y que el trasvase instantaneo
    conserve la carga o el flujo.

La comparacion es por columna, con tolerancia relativa 1e-6 sobre el mayor
valor absoluto de la columna; la exacta del corpus viene con 10 cifras.

Con siru no se compara fila por fila: la regla de conmutacion es la misma
--la condicion al comenzar el paso-- pero el paso no: el de siru lo elige su
integrador (aca, adaptativo) y el de la malla sale de --puntos. Con el mismo
paso coinciden: en lazo-bateria-llave, con --puntos 60 (paso 1/10), el
horario da 0|1 y 1|31/10, los mismos instantes del .simul de siru
(MOTORES.md, el motor maxima).

Copyright (C) Diego Saravia <dsa@unsa.edu.ar>
GPL version 3 o posterior.
"""
import argparse, os, re, shutil, subprocess, sys, tempfile

AQUI = os.path.dirname(os.path.abspath(__file__))
LANZADOR = os.path.join(AQUI, '..', 'bin', 'lanzador')
CORPUS = os.path.abspath(os.path.join(AQUI, '..', '..', 'corpus', 'corpus'))

# caso: (fuentes a copiar, la que entra, estado esperado, lo que tiene que
# decir el POR QUE TERMINO, el .exacta con el que se compara, y para los
# circuitos con llaves un diccionario de comprobaciones:
#   'horario': los renglones esperados (nro, desde, hasta, llaves), tal cual
#              los escribe Maxima: el instante es un punto de la malla, y
#              exacto (un racional: 51/50 con paso 1/50);
#   'saltos':  en cada conmutacion con trasvase, (tiempo, la magnitud que se
#              conserva como [(columna, coeficiente)], y las igualdades que
#              valen despues del salto)
#   'opciones': lo que se le agrega al lanzador (--paso 1/10)
CASOS = [
    ('RC de un estado', ['asades2015/abc.vuelta.d'], 'abc.vuelta.d', 0,
     'Termino la solucion analitica', 'asades2015/abc.exacta'),
    ('seis elementos, tres estados', ['chopped/6elementos-condiciones.d'],
     '6elementos-condiciones.d', 0, 'Termino la solucion analitica',
     'chopped/6elementos-condiciones.exacta'),
    ('par M/DU: las CI salen del DU', ['GLM/bdf3.M.dsa', 'GLM/bdf3.DU.dsa'],
     'bdf3.M.dsa', 0, 'Termino la solucion analitica', None),
    ('una tabla no es analitica', ['tanque/tanque_2.d'], 'tanque_2.d', 3,
     'una tabla no es una funcion analitica', None),
    ('no lineal: no hay forma cerrada', ['planeta1/planeta1_3.d'], 'planeta1_3.d', 3,
     'No hay solucion analitica', None),
    ('llaves: corte de bobinas, trasvase de flujo',
     ['llaves/corte-bobinas-llave.M.dsa', 'llaves/corte-bobinas-llave.DU.dsa'],
     'corte-bobinas-llave.M.dsa', 0, 'Termino la solucion analitica (maxima), 3 de 3 intervalos',
     None,
     {'horario': [('0', '0', '51/50', 'S1=0'), ('1', '51/50', '3', 'S1=1'),
                  ('2', '3', '6', 'S1=0')],
      # la condicion es (T>1)*(T<3): el paso que empieza en T=1 todavia tiene
      # la llave abierta y cierra en 51/50; el que empieza en T=3 ya la tiene
      # abierta, asi que ahi abre justo.
      # al abrirse la llave en T=3 las dos bobinas vuelven al corte: se
      # conserva el flujo L1*IL1 + L2*IL2 (L1=1, L2=2) y quedan con la misma
      # corriente
      'saltos': [(3.0, [('IL1', 1.0), ('IL2', 2.0)], [('IL1', 'IL2')])]}),
    ('llaves: lazo de capacitores, trasvase de carga',
     ['llaves/lazo-capacitores-llave.M.dsa', 'llaves/lazo-capacitores-llave.DU.dsa'],
     'lazo-capacitores-llave.M.dsa', 0, 'Termino la solucion analitica (maxima), 3 de 3 intervalos',
     None,
     {'horario': [('0', '0', '1', 'S1=1'), ('1', '1', '151/50', 'S1=0'),
                  ('2', '151/50', '6', 'S1=1')],
      # la condicion es (T<1)+(T>3): abre justo en T=1 y cierra en 151/50,
      # el paso siguiente a T=3
      # al cerrarse el lazo se conserva la carga QC1 + QC2 y los dos
      # capacitores quedan con el mismo voltaje
      'saltos': [(3.02, [('QC1', 1.0), ('QC2', 1.0)], [('VC1', 'VC2')])]}),
    # el mismo caso con el paso de siru: el horario tiene que dar los
    # instantes del .simul del corpus (1 y 31/10), que es lo que prueba que
    # --paso llega del lanzador a din2mac y de ahi a la malla y al horario
    ('llaves: con el paso de siru (--paso 1/10)',
     ['llaves/lazo-bateria-llave.M.dsa', 'llaves/lazo-bateria-llave.DU.dsa'],
     'lazo-bateria-llave.M.dsa', 0, 'Termino la solucion analitica (maxima), 3 de 3 intervalos',
     None,
     {'opciones': ['--paso', '1/10'],
      # aca no se comprueba el trasvase: lo da la bateria, que pone QC1 en
      # 0.5 sin conservar nada (eso se comprueba en los dos casos de arriba)
      'horario': [('0', '0', '1', 'S1=1'), ('1', '1', '31/10', 'S1=0'),
                  ('2', '31/10', '6', 'S1=1')]}),
    # la condicion depende del ESTADO: el horario no se puede calcular de
    # antemano y el modelo de cada configuracion se arma cuando aparece
    # (intervalo por intervalo). Con paso 1/10, la llave cierra hasta que
    # IL1 cruza 0.3 en el paso que empieza en 1/2, y el trasvase del corte
    # la deja oscilando unos ciclos hasta quedar abierta desde 6/5.
    ('llaves: condicion sobre el estado, por intervalos',
     ['llaves/llave-corriente-bobina.M.dsa', 'llaves/llave-corriente-bobina.DU.dsa'],
     'llave-corriente-bobina.M.dsa', 0,
     'Termino la solucion analitica (maxima), 8 intervalos', None,
     {'opciones': ['--paso', '1/10'],
      'horario': [('0', '0', '1/2', 'S1=1'), ('1', '1/2', '3/5', 'S1=0'),
                  ('2', '3/5', '4/5', 'S1=1'), ('3', '4/5', '9/10', 'S1=0'),
                  ('4', '9/10', '1', 'S1=1'), ('5', '1', '11/10', 'S1=0'),
                  ('6', '11/10', '6/5', 'S1=1'), ('7', '6/5', '10', 'S1=0')],
      # al abrirse en 1/2 el corte de bobinas conserva el flujo
      # L1*IL1 + L2*IL2 (L1=1, L2=2) y deja las corrientes iguales
      'saltos': [(0.5, [('IL1', 1.0), ('IL2', 2.0)], [('IL1', 'IL2')])]}),
    # la condicion sobre una variable ALGEBRAICA (IR1 no es un estado):
    # tambien se evalua sobre la formula cerrada del intervalo
    ('llaves: condicion sobre una variable algebraica',
     ['llaves/llave-corriente-resistencia.M.dsa', 'llaves/llave-corriente-resistencia.DU.dsa'],
     'llave-corriente-resistencia.M.dsa', 0,
     'Termino la solucion analitica (maxima)', None,
     {'opciones': ['--paso', '1/10']}),
]

def leer_tabla(path):
    """Un .exacta o un .tabla: la cabecera de nombres y las filas de numeros."""
    nombres, filas = [], []
    with open(path) as fh:
        for linea in fh:
            if linea.startswith('#'):
                partes = linea.lstrip('#').split()
                if partes and partes[0].upper() in ('TIME', 'T') and not nombres:
                    nombres = [p.upper() for p in partes]
                continue
            if linea.split():
                filas.append([float(x) for x in linea.split()])
    return nombres, filas

def comparar(nuestra, exacta, tol=1e-6):
    """Las columnas comunes, en los tiempos de la exacta. Devuelve (peor, donde)."""
    n_nom, n_fil = leer_tabla(nuestra)
    e_nom, e_fil = leer_tabla(exacta)
    if not n_nom or not e_nom:
        return None, 'sin cabecera de nombres'
    comunes = [c for c in e_nom[1:] if c in n_nom]
    if not comunes:
        return None, 'ninguna columna en comun'
    peor, donde = 0.0, ''
    for ef in e_fil:
        t = ef[0]
        # la fila de nuestra tabla en ese tiempo; la malla es equidistante
        cerca = min(n_fil, key=lambda f: abs(f[0] - t))
        if abs(cerca[0] - t) > 1e-9 * max(1.0, abs(t)):
            return None, 'el tiempo %g de la exacta no esta en la malla' % t
        for col in comunes:
            v_n = cerca[n_nom.index(col)]
            v_e = ef[e_nom.index(col)]
            escala = max(abs(x[e_nom.index(col)]) for x in e_fil) or 1.0
            dif = abs(v_n - v_e) / escala
            if dif > peor:
                peor, donde = dif, '%s en t=%g (%.10g contra %.10g)' % (col, t, v_n, v_e)
    return (peor, donde) if peor <= tol else (None, 'difiere: ' + donde)

def comprobar_horario(path, esperado):
    """Los renglones del .horario, tal cual: el instante tiene que ser exacto."""
    if not os.path.isfile(path):
        return ['no dejo el horario de las llaves']
    visto = []
    with open(path) as fh:
        for linea in fh:
            if not linea.startswith('intervalo'):
                continue
            campos = [c.strip() for c in linea.split('|')]
            nro = campos[0].split()[1]
            visto.append((nro, campos[1], campos[2], campos[5]))
    if visto != [tuple(e) for e in esperado]:
        return ['el horario es %s y se esperaba %s' % (visto, esperado)]
    return []

def comprobar_salto(path, cuando, conserva, iguales, tol=1e-9):
    """En la conmutacion: dos filas, la magnitud conservada y las igualdades."""
    nombres, filas = leer_tabla(path)
    enel = [f for f in filas if abs(f[0] - cuando) <= 1e-9 * max(1.0, abs(cuando))]
    if len(enel) != 2:
        return ['en t=%g hay %d filas y tenian que ser dos (antes y despues '
                'del trasvase)' % (cuando, len(enel))]
    problemas = []
    def magnitud(fila):
        return sum(coef * fila[nombres.index(col)] for col, coef in conserva)
    antes, despues = magnitud(enel[0]), magnitud(enel[1])
    escala = max(abs(antes), abs(despues), 1e-30)
    if abs(antes - despues) / escala > 1e-9:
        problemas.append('el trasvase en t=%g no conserva %s: %.17g contra %.17g'
                         % (cuando, '+'.join(c for c, _ in conserva), antes, despues))
    for a, b in iguales:
        va, vb = enel[1][nombres.index(a)], enel[1][nombres.index(b)]
        if abs(va - vb) > tol * max(abs(va), abs(vb), 1.0):
            problemas.append('despues del trasvase en t=%g, %s=%.17g y %s=%.17g'
                             % (cuando, a, va, b, vb))
    return problemas

def main():
    ap = argparse.ArgumentParser(description=__doc__,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument('--ver', action='store_true', help='mostrar lo que dice el lanzador')
    args = ap.parse_args()
    if not shutil.which('maxima') and not os.environ.get('MAXIMA'):
        print('probar-maxima: maxima no esta instalado; no se puede probar el motor')
        return 3
    fallas = 0
    print('%-46s %-7s %s' % ('caso', 'estado', 'que paso'))
    for caso in CASOS:
        nombre, fuentes, entrada, esperado, dice, exacta = caso[:6]
        comprobaciones = caso[6] if len(caso) > 6 else {}
        falta = [f for f in fuentes if not os.path.isfile(os.path.join(CORPUS, f))]
        if falta:
            print('%-46s %-7s %s' % (nombre, '-', 'falta en el corpus: ' + ', '.join(falta)))
            fallas += 1
            continue
        with tempfile.TemporaryDirectory(prefix='probar-maxima-') as tmp:
            for f in fuentes:
                shutil.copy(os.path.join(CORPUS, f), os.path.join(tmp, os.path.basename(f)))
            p = subprocess.run([LANZADOR, '--motor', 'maxima']
                               + comprobaciones.get('opciones', []) + [entrada],
                               cwd=tmp, capture_output=True, text=True, timeout=900)
            if args.ver:
                print(p.stdout)
                print(p.stderr)
            salida = p.returncode
            porque = ''
            for l in p.stderr.splitlines():
                if 'POR QUE TERMINO:' in l:
                    porque = l.split('POR QUE TERMINO:', 1)[1].strip()
            problemas = []
            if salida != esperado:
                problemas.append('estado %d, se esperaba %d' % (salida, esperado))
            if dice not in porque:
                problemas.append('dijo %r' % porque)
            if not problemas and esperado == 0 and exacta:
                base = os.path.splitext(entrada)[0]
                tabla = os.path.join(tmp, base + '.tabla')
                if not os.path.isfile(tabla):
                    problemas.append('no dejo la tabla')
                else:
                    peor, donde = comparar(tabla, os.path.join(CORPUS, exacta))
                    if peor is None:
                        problemas.append(donde)
                    else:
                        porque += '; contra la exacta: %.1e (%s)' % (peor, donde)
            if not problemas and esperado == 0 and comprobaciones:
                base = os.path.splitext(entrada)[0]
                if 'horario' in comprobaciones:
                    problemas += comprobar_horario(os.path.join(tmp, base + '.horario'),
                                                   comprobaciones['horario'])
                tabla = os.path.join(tmp, base + '.tabla')
                if not os.path.isfile(tabla):
                    problemas.append('no dejo la tabla')
                else:
                    saltos = comprobaciones.get('saltos', [])
                    for cuando, conserva, iguales in saltos:
                        problemas += comprobar_salto(tabla, cuando, conserva, iguales)
                    if not problemas:
                        porque += '; horario y trasvase, bien' if saltos else '; horario, bien'
            if problemas:
                fallas += 1
                print('%-46s %-7s MAL: %s' % (nombre, salida, '; '.join(problemas)))
            else:
                print('%-46s %-7s %s' % (nombre, salida, porque))
    print()
    print('fallas: %d de %d' % (fallas, len(CASOS)))
    return 1 if fallas else 0

if __name__ == '__main__':
    sys.exit(main())
