#!/usr/bin/env python3
"""Ejecutar el catalogo INTEGRA sobre un M/DU comun y producir un PDF auditable.

Requiere Maxima, numpy, scipy y matplotlib. No abre Simplot ni modifica el corpus.
Solo el selector numerico cambia entre casos. --ids limita una prueba; por
defecto incluye cada entrada ejecutable y enumera por separado las reservas.
"""
import argparse
from concurrent.futures import ThreadPoolExecutor, as_completed
from collections import Counter
import csv
from datetime import datetime, timezone
import hashlib
import json
import os
import platform
from pathlib import Path
import re
import shlex
import signal
import subprocess
import textwrap
import time

import numpy as np
from scipy.linalg import expm

SIRU = Path(__file__).resolve().parents[1]
TREE = SIRU.parent
CATALOG = TREE / 'slex/d2datdinc/biblioteca/integra.json'
EXAMPLE = SIRU / 'ejemplos/6elementos-integradores'
CURRENTS = ('IR12', 'IL23', 'IR3', 'IC3', 'IL2', 'IE1')
J = np.array([[-1., -1., 0.], [-1., -1., -1.], [0., 1., -1.]])
NUMERICAL_ENV = ('PERL5LIB', 'PYTHONPATH', 'LD_LIBRARY_PATH',
                 'SIRU_PASO_FACTOR', 'SIRU_PLAZO_TOTAL', 'SIRU_ROS_ITERACIONES',
                 'SIRU_ROS_LINEAL', 'SIRU_ROS_PRECONDICIONADOR', 'SIRU_ROS_RTOL',
                 'SIRU_PGLM_LINEAL', 'SIRU_PGLM_PRECONDICIONADOR', 'SIRU_PGLM_MOTOR',
                 'SIRU_SALIDA_PASO', 'TABULAR_RESULTADOS')


def numerical_environment():
    return {k: os.environ[k] for k in NUMERICAL_ENV if k in os.environ}


def digest(path):
    return hashlib.sha256(Path(path).read_bytes()).hexdigest()


def save_json(path, data):
    tmp = path.with_suffix('.tmp')
    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2, allow_nan=False) + '\n')
    tmp.replace(path)


def reference(times):
    rows = []
    for t in times:
        x, y, z = np.array([1., 0., 0.]) - expm(J * t) @ np.array([1., 0., 0.])
        rows.append([x + y, y, z, y - z, x, x + y])
    return np.asarray(rows)


def read_output(path):
    # Admite salida temporal y diagnostica datos incompletos o no finitos.
    header = ['TIME', *CURRENTS]
    if not any(line.lstrip('# ').split() == header for line in path.read_text().splitlines()
               if line.startswith('#')):
        raise ValueError('la cabecera no identifica las seis corrientes en el orden esperado')
    a = np.loadtxt(path, ndmin=2)
    if a.shape[1] != 7 or not len(a) or not np.isfinite(a).all():
        raise ValueError('la salida no tiene tiempo y seis corrientes finitas')
    if len(a) > 1 and not np.all(np.diff(a[:, 0]) > 0):
        raise ValueError('los tiempos de salida no son estrictamente crecientes')
    return a


def explanation(number, motor, log, timed_out, returncode):
    if timed_out:
        return 'Límite de ejecución agotado. No demuestra incompatibilidad matemática; falta completar esta corrida.'
    if returncode == 0:
        return 'La ejecución terminó; las medidas de error se refieren a los puntos efectivamente obtenidos.'
    prefixes = {
        'SDE': 'Este circuito no define ruido. No se añade una excitación estocástica para habilitar el método.',
        'RETARDO': 'El circuito no contiene retardos ni historia anterior. No se altera su dinámica para incorporarlos.',
        'RATTLE': 'El circuito no declara posiciones, velocidades y restricciones mecánicas para RATTLE.',
    }
    clean = [s for s in log.splitlines() if s.strip() and 'no se usa ' not in s
             and not s.startswith(('Evolucion DU:', 'siru: controles'))]
    detail = '\n'.join(clean[-8:])[-2300:]
    prefix = prefixes.get(motor, 'El programa rechazó o no completó este caso. El diagnóstico no prueba por sí solo que la fórmula sea inaplicable.')
    if number == -1:
        prefix = '−1 es una operación de un punto, no un integrador temporal. Se conserva el diagnóstico de la misma llamada M/DU.'
    return prefix + '\n\n' + detail


def fingerprint(args):
    paths = [Path(__file__).resolve(), CATALOG, EXAMPLE / '6elementos.M.dsa',
             EXAMPLE / '6elementos.DU.dsa', SIRU / 'bin/siru', Path(args.calcula),
             TREE / 'slex/d2datdinc/d2datdinc',
             SIRU / 'doc/6elementos-integradores/solucion.mac',
             SIRU / 'doc/6elementos-integradores/comparar-maxima.py']
    paths += list((SIRU / 'lib').rglob('*.pm'))
    paths += list((TREE / 'slex/d2datdinc/biblioteca').glob('*.json'))
    paths += list((TREE / 'slex/viejos/dsa-python').glob('*.py'))
    paths += list(Path(args.bibliotecas).glob('*.so*'))
    # En el arbol de compilacion estos ejecutables pueden ser envoltorios
    # libtool que no cambian al recompilar. Incluir el binario real y Slex.
    for executable in (Path(args.calcula), TREE / 'slex/d2datdinc/d2datdinc'):
        paths.append(executable.parent / '.libs' / executable.name)
    paths += list((TREE / 'slex/src/.libs').glob('*.so*'))
    hashes = {str(p): digest(p) for p in sorted(set(paths)) if p.is_file()}
    value = hashlib.sha256(json.dumps([hashes, numerical_environment(), args.paso_inicial], sort_keys=True).encode()).hexdigest()
    return value, hashes


def run_case(number, descriptor, args, template, source_hash, revision):
    stem = f'metodo-{number}'
    meta = args.salida / (stem + '.json')
    if args.reanudar and meta.exists():
        old = json.loads(meta.read_text())
        # Un timeout se reintenta si se amplió el límite; el resto se reutiliza
        # solo con el mismo código, fuentes y subproductos íntegros.
        artifacts = old.get('archivos', {})
        intact = all((args.salida / p).is_file() and digest(args.salida / p) == h
                     for p, h in artifacts.items())
        if old.get('huella_ejecucion') == source_hash and artifacts and intact and not (
                old.get('estado') == 'timeout' and args.limite > old.get('limite_s', 0)):
            return old
    du = args.salida / (stem + '.DU.dsa')
    out = args.salida / (stem + '.simul')
    log = args.salida / (stem + '.log')
    text, n = re.subn(r'^INTEGRA=\[[^\n]*\]', f'INTEGRA=[{number}]', template, flags=re.M)
    if n != 1:
        raise ValueError('la plantilla debe tener exactamente una declaración INTEGRA')
    # Verificación explícita: ninguna modificación adicional entre casos.
    assert re.sub(r'^INTEGRA=\[[^\n]*\]', 'INTEGRA=[]', text, flags=re.M) == re.sub(
        r'^INTEGRA=\[[^\n]*\]', 'INTEGRA=[]', template, flags=re.M)
    du.write_text(text)
    state = Path(str(out) + '.estado.json')
    for product in (out, state):
        if product.exists():
            product.unlink()  # subproductos de este caso, nunca fuentes ni corpus
    cmd = ['perl', str(SIRU / 'bin/siru'), '--modelo', str(EXAMPLE / '6elementos.M.dsa'),
           '--salida', str(out), '--calcula', args.calcula, '--bibliotecas', args.bibliotecas]
    env = dict(os.environ, SIRU_NOSIMPLOT='1', OPENBLAS_NUM_THREADS='1', OMP_NUM_THREADS='1')
    started = time.monotonic()
    timed_out = False
    with du.open() as src, log.open('w') as dst:
        proc = subprocess.Popen(cmd, stdin=src, stdout=dst, stderr=dst, env=env,
                                cwd=TREE, start_new_session=True)
        try:
            code = proc.wait(timeout=args.limite)
        except subprocess.TimeoutExpired:
            timed_out = True
            os.killpg(proc.pid, signal.SIGKILL)
            code = proc.wait()
    logtext = log.read_text(errors='replace')
    record = dict(numero=number, nombre=descriptor['nombre'], motor=descriptor['motor'],
                  estado='timeout' if timed_out else 'rechazado' if code else 'completo',
                  codigo_salida=code, segundos=round(time.monotonic()-started, 3),
                  limite_s=args.limite, revision=revision, huella_ejecucion=source_hash,
                  comando='SIRU_NOSIMPLOT=1 ' + shlex.join(cmd) + ' < ' + shlex.quote(str(du)),
                  diagnostico=explanation(number, descriptor['motor'], logtext, timed_out, code))
    summary = re.search(r'^Evolucion DU: (.*)$', logtext, re.M)
    if summary:
        record['estadisticas'] = json.loads(summary[1])
    if code == 0:
        try:
            a = read_output(out)
            record.update(filas=len(a), tiempo_final=float(a[-1, 0]),
                          error_max_A=float(np.max(np.abs(a[:, 1:] - reference(a[:, 0])))))
            if number == -1 and len(a) == 1:
                record['estado'] = 'punto'
            elif abs(a[0, 0]) > 1e-12 or abs(a[-1, 0]-10) > 1e-10:
                record['estado'] = 'incompleto'
                record['diagnostico'] = 'Salida disponible, pero no cubre el intervalo solicitado [0,10] s.'
        except (ValueError, OSError) as exc:
            record['estado'] = 'salida_invalida'
            record['diagnostico'] = str(exc)
    record['archivos'] = {p.name: digest(p) for p in (du, out, log, state) if p.exists()}
    save_json(meta, record)
    return record


def pdf_report(records, catalog, args, metadata, reference_function=None):
    os.environ.setdefault('MPLCONFIGDIR', '/tmp/siru-matplotlib')
    import matplotlib
    matplotlib.use('Agg')
    import matplotlib.pyplot as plt
    from matplotlib.backends.backend_pdf import PdfPages
    ranking = metadata.get('analisis_maxima', {}).get('ecm_50')
    ordered = (sorted(records, key=lambda r: (0, r['ecm_50']['puesto']) if 'ecm_50' in r
                      else (1, r['numero'])) if ranking else records)

    def text_page(pdf, title, paragraphs):
        fig = plt.figure(figsize=(11.7, 8.3))
        fig.text(.06, .93, title, fontsize=19, weight='bold')
        y = .86
        for p in paragraphs:
            lines = '\n'.join(textwrap.fill(line, width=116) for line in p.splitlines())
            fig.text(.06, y, lines, fontsize=11, va='top', linespacing=1.45)
            y -= .034 * (lines.count('\n') + 1) + .026
        pdf.savefig(fig)
        plt.close(fig)

    temporary_pdf = args.salida / '6elementos-integradores.pdf.tmp'
    with PdfPages(temporary_pdf) as pdf:
        counts = Counter(r['estado'] for r in records)
        text_page(pdf, '6elementos: corrientes con el catálogo INTEGRA', [
            f"Fecha UTC: {metadata['fecha_utc']} · Revisión de trabajo: {metadata['revision']}",
            f"Selecciones examinadas: {len(records)} de {len(catalog['methods'])} disponibles. "
            f"Reservas todavía no ejecutables: {len(catalog['reservados'])}.",
            'Resultados: ' + '; '.join(f'{k}: {v}' for k, v in sorted(counts.items())) + '.',
            f"Un mismo circuito M y un mismo DU: solo cambia el número INTEGRA. Se agregaron campos y mapas auxiliares sin cambiar las ramas ni sus valores unitarios. Tiempo final 10 s; paso inicial común {metadata.get('paso_inicial_s', .05):g} s, máximo 0.2 s. Se conserva la política de adaptación por defecto de cada motor.",
            ('Métodos ordenados por error RMS creciente en 50 tiempos comunes. La clasificación y sus condiciones preceden a los gráficos; los casos sin trayectoria completa quedan al final.' if ranking else
             'Cada página siguiente corresponde a un número, en orden creciente. Un resultado completo se contrasta con la solución independiente. Un rechazo o un timeout se muestra como tal; no se sustituye por la curva de referencia ni por otro integrador.'),
            'Solo se dibujan corrientes. IR12 e IE1 coinciden: ambas se conservan con trazos distintos. Un gráfico no demuestra orden de convergencia ni equivalencia general entre métodos.',
            'Archivos acompañantes: resumen.csv, inventario.json, manifiesto.json, M/DU exactos y un JSON, log y salida disponible por selección. Las reservas figuran en inventario.json y no se cuentan como corridas.',
            *(['Solución exacta obtenida con Maxima. Cada trayectoria incluye su error absoluto por corriente. Errores por punto: errores-metodo-N.csv; máximos: errores-absolutos.csv; auditoría del análisis: analisis-maxima.json.'] if reference_function else [])
        ])
        text_page(pdf, 'Qué se calcula y cómo se comprueba', [
            'Estados: x=IL2, y=IL23, z=QC3. Inicialmente x=y=z=0.\nx′=1−x−y; y′=1−x−y−z; z′=y−z.',
            'Corrientes: IR12=x+y; IL23=y; IR3=z; IC3=y−z; IL2=x; IE1=x+y.',
            'Referencia: u(t)=u*−exp(Jt)u*, u*=(1,0,0), J=[[-1,-1,0],[-1,-1,-1],[0,1,-1]]. El error indicado es el máximo absoluto de las seis corrientes en los tiempos realmente obtenidos.',
            'Partición aditiva: A=(−x,−y,−z), B=(1−y,1−x−z,y), A+B=f. Partición de estados: (IL2,IL23) y (QC3). Para exponenciales se ofrece L=−I. Cada motor usa solo la información pertinente.',
            'Composiciones SPLIT: A usa el polinomio de Taylor de exp(−h) hasta orden 12. B tiene un flujo afín exacto de grado 3. Se declaran mapas aproximados, no flujos todos exactos. Las expresiones completas están en el DU y README del ejemplo.',
            'Este circuito disipativo no define ruido, retardos ni restricciones mecánicas. No se agrega otra física para activar métodos especializados. Los diagnósticos de los ejecutores se conservan literalmente en los logs.',
            'La adaptación, los pasos y los rechazos pueden diferir entre motores. Se registran en el JSON de cada caso cuando el ejecutor los informa. Completar la corrida no implica satisfacer una tolerancia global ni probar todas las capacidades del método.'
        ])
        if reference_function:
            fig = plt.figure(figsize=(11.7, 8.3))
            fig.text(.06, .93, 'Solución analítica y error absoluto', fontsize=19, weight='bold')
            fig.text(.06, .86, 'Maxima resuelve las tres ecuaciones diferenciales con condiciones iniciales nulas mediante desolve.\nVerifica exactamente los tres residuos diferenciales y los tres valores iniciales.',
                     fontsize=11, va='top', linespacing=1.5)
            fig.text(.06, .75, r'$x=1-(1+t^2/2)e^{-t},\quad y=t e^{-t},\quad z=(t^2/2)e^{-t}$', fontsize=17)
            rows = [
                ['IR12 = IE1', r'$1-(1-t+t^2/2)e^{-t}$'],
                ['IL23', r'$t e^{-t}$'], ['IR3', r'$(t^2/2)e^{-t}$'],
                ['IC3', r'$(t-t^2/2)e^{-t}$'], ['IL2', r'$1-(1+t^2/2)e^{-t}$']]
            ax = fig.add_axes([.1, .36, .8, .34]); ax.axis('off')
            table = ax.table(cellText=rows, colLabels=['Corriente (A)', 'Solución exacta (t en s)'],
                             cellLoc='center', loc='center', bbox=[0, 0, 1, 1])
            table.auto_set_font_size(False); table.set_fontsize(14)
            fig.text(.06, .28, r'$e_i(t)=|I_{i,\mathrm{Siru}}(t)-I_{i,\mathrm{Maxima}}(t)|$', fontsize=17)
            fig.text(.06, .22, 'Se compara en cada tiempo realmente escrito por Siru, sin interpolación. El máximo se toma sobre\nesos puntos; no es una cota del error entre ellos. El error final y el instante del máximo figuran en el CSV.\nLas fórmulas son exactas; su evaluación y la resta usan doble precisión. Errores del orden de 10⁻¹⁵ A\npueden reflejar redondeo. Una sola corrida no demuestra el orden del método.',
                     fontsize=11, va='top', linespacing=1.5)
            fig.text(.06, .045, 'Fuente: solucion.mac · Fórmulas derivadas: referencia-maxima.json · Verificación: maxima.log', fontsize=10)
            pdf.savefig(fig); plt.close(fig)
        if ranking:
            text_page(pdf, 'Comparación en 50 instantes equiespaciados', [
                'Intervalo: de 0 a 10 s, ambos extremos incluidos. t_k=10 k/49, k=0,…,49; separación 0.20408163265306123 s. No son 50 pasos: son 50 puntos.',
                'Las salidas originales tienen mallas distintas. Se interpola linealmente cada corriente de Siru en esos tiempos y se evalúa directamente la solución analítica de Maxima. No se interpola el error ni se extrapola fuera de la trayectoria.',
                'Error RMS = √{(1/300) Σ_i Σ_k [I_i,interpolada(t_k)−I_i,Maxima(t_k)]²}, en A: raíz del promedio de los cuadrados en 50 instantes y seis corrientes. Se muestra una sola medida de error.',
                'Las seis corrientes tienen igual peso. IR12 e IE1 coinciden, pero se cuentan por separado porque ambas forman parte de los resultados solicitados. Los archivos de auditoría conservan las sumas y los cuadrados usados en el cálculo.',
                'Se ordena por error RMS global sin redondear. En empates exactos se usa el número INTEGRA para mantener un orden reproducible. Los casos sin trayectoria completa no reciben error RMS cero ni un puesto.',
                'Esta comparación mide las corridas y su interpolación: depende del paso, la adaptación y la densidad de salida. El error de interpolación puede dominar en métodos de alta precisión; el orden no es una clasificación universal de las fórmulas de integración.',
                f"Clasificados: {len(ranking['clasificacion'])}. Sin clasificación: {len(ranking['sin_clasificar'])}. Tabla completa: clasificacion-ecm-50.csv. Los 50 valores, referencias y errores cuadrados por corriente están en muestras-ecm-50.csv.",
                'Tiempo (s): duración de reloj registrada de cada corrida, incluida la preparación del modelo, la integración y la escritura de salidas. No mide solo la integración ni tiempo CPU. La carga de la máquina y las corridas concurrentes influyen; los tiempos no se vuelven a medir al generar este informe.'
            ])
            rows_per_page = 22
            ranked = ranking['clasificacion']
            for first in range(0, len(ranked), rows_per_page):
                group = ranked[first:first+rows_per_page]
                fig = plt.figure(figsize=(11.7, 8.3))
                fig.text(.05, .94, f"Menor a mayor error RMS · puestos {first+1}–{first+len(group)} de {len(ranked)}", fontsize=17, weight='bold')
                fig.text(.05, .885, '50 tiempos en [0,10] s · seis corrientes · interpolación lineal · referencia Maxima', fontsize=10)
                cells = [[str(r['puesto']), str(r['numero']),
                          textwrap.fill(textwrap.shorten(r['nombre'], 100, placeholder='…'), 55),
                          f"{r['recm_A']:.6e}",
                          f"{r['tiempo_ejecucion_s']:.3f}"] for r in group]
                ax = fig.add_axes([.05, .10, .9, .74]); ax.axis('off')
                height = (len(group)+1)/(rows_per_page+1)
                table = ax.table(cellText=cells, colLabels=['Puesto', 'INTEGRA', 'Método', 'Error RMS (A)', 'Tiempo (s)'],
                                 colWidths=[.06, .07, .60, .17, .10], cellLoc='left',
                                 bbox=[0, 1-height, 1, height])
                table.auto_set_font_size(False); table.set_fontsize(8)
                for (i, j), cell in table.get_celld().items():
                    cell.set_linewidth(.35)
                    if i == 0:
                        cell.set_facecolor('#e5edf5'); cell.set_text_props(weight='bold')
                    elif i % 2 == 0:
                        cell.set_facecolor('#f4f6f8')
                fig.text(.05, .05, 'Tiempo total de reloj por corrida, incluida preparación y salida. Orden por ECM sin redondear; tolerancias según motor.', fontsize=9)
                pdf.savefig(fig); plt.close(fig)
        for r in ordered:
            title = f"INTEGRA=[{r['numero']}] — {r['nombre']}"
            fig = plt.figure(figsize=(11.7, 8.3))
            fig.text(.06, .95, textwrap.fill(title, 70), fontsize=15, weight='bold', va='top')
            position = f" · Puesto ECM: {r['ecm_50']['puesto']}/{len(ranking['clasificacion'])}" if 'ecm_50' in r else ''
            fig.text(.06, .86, f"Motor: {r['motor']} · Estado: {r['estado']} · Ejecución: {r['segundos']:.2f} s{position}", fontsize=11)
            if r['estado'] in ('completo', 'incompleto', 'punto'):
                a = read_output(args.salida / f"metodo-{r['numero']}.simul")
                ax = fig.add_axes([.09, .52, .86, .29] if reference_function else [.09, .24, .86, .54])
                styles = ['-', '-', '-', '-', '--', ':']
                for i, name in enumerate(CURRENTS):
                    ax.plot(a[:, 0], a[:, i+1], styles[i], label=name,
                            marker='o' if len(a) == 1 else None, linewidth=1.8)
                ax.set(xlabel='Tiempo (s)', ylabel='Corriente (A)')
                ax.grid(alpha=.25)
                ax.legend(ncol=3, fontsize=10)
                if reference_function:
                    error = np.abs(a[:, 1:] - reference_function(a[:, 0]))
                    ax_error = fig.add_axes([.09, .19, .86, .23])
                    for i, name in enumerate(CURRENTS):
                        ax_error.plot(a[:, 0], error[:, i], styles[i], label=name, linewidth=1.4)
                    ax_error.set(xlabel='Tiempo (s)', ylabel='Error absoluto (A)', ylim=(0, None))
                    ax_error.grid(alpha=.25)
                    fig.text(.09, .445, 'Error respecto de Maxima · mismos colores que las corrientes', fontsize=10)
                fig.text(.09, .105 if reference_function else .16, f"Puntos: {r['filas']} · Último tiempo: {r['tiempo_final']:.12g} s · Error máximo: {r['error_max_A']:.6g} A", fontsize=11)
                metric = r.get('ecm_50')
                footer = (f"Error RMS en 50 tiempos: {metric['recm_A']:.6e} A · Interpolación lineal" if metric else
                          'El error se mide en los puntos de salida; no es una cota entre puntos ni una certificación del método.')
                fig.text(.09, .075 if reference_function else .11, footer, fontsize=9)
            else:
                reason = '\n'.join(textwrap.fill(line, 116) for line in r['diagnostico'].splitlines())
                if len(reason.splitlines()) > 25:
                    reason = '\n'.join(reason.splitlines()[:24]) + '\n[Diagnóstico completo en el log.]'
                fig.text(.06, .77, reason, fontsize=10, va='top', linespacing=1.5)
            fig.text(.06, .045, f"Registro y comando: metodo-{r['numero']}.json · Diagnóstico: metodo-{r['numero']}.log", fontsize=9)
            pdf.savefig(fig)
            plt.close(fig)
        pdf.infodict().update(Title='6elementos: comparación del catálogo INTEGRA',
                             Author='Proyecto Siru', Subject='Corrientes y diagnósticos reproducibles')
    temporary_pdf.replace(args.salida / '6elementos-integradores.pdf')


def main():
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument('--salida', type=Path, default=Path('/tmp/6elementos-integradores'))
    p.add_argument('--calcula', default=str(TREE.parent/'calcula/calcula-6.0/src/calcula'))
    p.add_argument('--bibliotecas', default=str(TREE.parent/'calcula/calcula-6.0/src/.libs'))
    p.add_argument('--trabajos', type=int, default=3)
    p.add_argument('--limite', type=float, default=180, help='segundos máximos por caso')
    p.add_argument('--ids', help='subconjunto de números separados por comas; por defecto todos')
    p.add_argument('--reanudar', action='store_true', help='reutilizar registros íntegros del mismo código')
    p.add_argument('--paso-inicial', type=float, default=.05, help='paso inicial común en segundos; máximo conservado 0.2 s')
    args = p.parse_args()
    if args.trabajos < 1 or args.limite <= 0:
        p.error('trabajos y limite deben ser positivos')
    if not np.isfinite(args.paso_inicial) or not 0 < args.paso_inicial <= .2:
        p.error('paso inicial debe ser finito, positivo y no mayor que 0.2 s')
    args.salida = args.salida.resolve()
    args.calcula = str(Path(args.calcula).resolve())
    args.bibliotecas = str(Path(args.bibliotecas).resolve())
    catalog = json.loads(CATALOG.read_text())
    ids = sorted(map(int, args.ids.split(','))) if args.ids else sorted(n for n in map(int, catalog['methods']) if n != -1 and n not in range(569, 573))
    if len(ids) != len(set(ids)) or any(str(n) not in catalog['methods'] for n in ids):
        p.error('la selección contiene duplicados, reservas o números desconocidos')
    args.salida.mkdir(parents=True, exist_ok=True)
    source_hash, hashes = fingerprint(args)
    revision = subprocess.check_output(['svnversion', str(TREE)], text=True).strip()
    metadata = dict(fecha_utc=datetime.now(timezone.utc).isoformat(), revision=revision,
                    huella_ejecucion=source_hash, archivos_fuente=hashes, numeros=ids,
                    entorno_numerico=numerical_environment(),
                    plataforma=platform.platform(), python=platform.python_version(),
                    procesador=next((line.split(':',1)[1].strip() for line in Path('/proc/cpuinfo').read_text().splitlines() if line.startswith('model name')), platform.machine()),
                    paso_inicial_s=args.paso_inicial, trabajos=args.trabajos,
                    comando=shlex.join([str(Path(__file__).resolve()), *os.sys.argv[1:]]))
    template = (EXAMPLE/'6elementos.DU.dsa').read_text().replace(
        'SIRU_PASO=[0.05]', f'SIRU_PASO=[{args.paso_inicial}]').replace(
        'Paso inicial 0.05 s.', f'Paso inicial {args.paso_inicial} s.')
    (args.salida/'6elementos.M.dsa').write_bytes((EXAMPLE/'6elementos.M.dsa').read_bytes())
    (args.salida/'6elementos.DU.dsa').write_text(template)
    save_json(args.salida/'inventario.json', catalog)
    save_json(args.salida/'manifiesto.json', metadata)
    records = []
    with ThreadPoolExecutor(max_workers=args.trabajos) as pool:
        jobs = []
        for n in ids:
            m = dict(catalog['methods'][str(n)])
            m['nombre'] = m.get('nombre') or catalog['descripciones'][str(n)]['nombre']
            jobs.append(pool.submit(run_case, n, m, args, template, source_hash, revision))
        for job in as_completed(jobs):
            r = job.result()
            records.append(r)
            print(f"{len(records)}/{len(ids)}: {r['numero']} {r['estado']} ({r['segundos']:.2f} s)", flush=True)
    records.sort(key=lambda x: x['numero'])
    if fingerprint(args)[0] != source_hash:
        metadata['consistente'] = False
        save_json(args.salida/'manifiesto.json', metadata)
        raise RuntimeError('Fuentes o binarios cambiaron durante las corridas; no se genera un PDF mezclando versiones. Repetir con --reanudar.')
    metadata['consistente'] = True
    save_json(args.salida/'manifiesto.json', metadata)
    fields = ['numero', 'nombre', 'motor', 'estado', 'codigo_salida', 'filas', 'tiempo_final', 'error_max_A', 'segundos']
    with (args.salida/'resumen.csv').open('w') as f:
        w = csv.DictWriter(f, fieldnames=fields, extrasaction='ignore')
        w.writeheader()
        w.writerows(records)
    subprocess.run(['python3', str(SIRU/'doc/6elementos-integradores/comparar-maxima.py'),
                    '--salida', str(args.salida)], check=True)
    print(json.dumps(Counter(r['estado'] for r in records), ensure_ascii=False))
    print(args.salida/'6elementos-integradores.pdf')


if __name__ == '__main__':
    main()
