#!/usr/bin/env python3
"""Mapa de dependencias del Fortran generado; no altera ni ejecuta ecuaciones.

El lector del modelo sigue siendo d2datdinc/slex. Aquí se reconoce únicamente
el formato fijo y las asignaciones del Fortran producido por SCEPTRE.
"""
import argparse
import json
import math
import sys
import os
from pathlib import Path
import re
import subprocess
import tempfile


def sentencias(texto):
    actual = None
    for numero, linea in enumerate(texto.splitlines(), 1):
        if not linea or linea[0] in 'Cc*!':
            continue
        cuerpo = linea[6:72].rstrip()
        if len(linea) > 5 and linea[5] not in ' 0':
            if actual:
                actual['texto'] += cuerpo
                actual['hasta'] = numero
            continue
        if actual:
            yield actual
        actual = dict(linea=numero, hasta=numero, texto=cuerpo,
                      generador=linea[73:].strip() if len(linea) > 73 else '')
    if actual:
        yield actual


LITERAL = re.compile(r"'(?:''|[^'])*'|\"(?:\"\"|[^\"])*\"")
NOMBRE = re.compile(r'[A-Z_][A-Z0-9_$]*(?:\(\s*\d+(?:\s*,\s*\d+)*\s*\))?', re.I)
ASIGNA = re.compile(r'^\s*([A-Z_][A-Z0-9_$]*(?:\([^)]*\))?)\s*(=>|=(?!=))\s*(.*)$', re.I)


def nombres(texto):
    return {re.sub(r'\s+', '', m.group()).upper()
            for m in NOMBRE.finditer(LITERAL.sub('', texto))}


def mapa(dato, fuente, generado):
    refs = []
    conocidos = {}
    for rama, origen in (dato.get('OTHERINFO', {}).get('origen_ramas') or {}).items():
        if not origen.get('archivo') or origen['archivo'] == 'modelo expandido':
            continue
        indice = len(refs)
        refs.append(dict(origen, rama=rama))
        for prefijo in ('', 'I', 'V', 'Q', 'D', 'DI', 'DV', 'DQ'):
            conocidos.setdefault((prefijo + rama).upper(), set()).add(indice)

    for nombre, ref in (dato.get('OTHERINFO', {}).get('origen_nombres') or {}).items():
        indice = len(refs)
        refs.append(dict(ref, nombre=nombre))
        conocidos.setdefault(nombre.upper(), set()).add(indice)

    origen_directo = {k: set(v) for k, v in conocidos.items()}
    estados_integracion = {}
    ecuaciones = []
    sistemas_lineales = []
    dependencias = {}
    lineas = list(sentencias(generado.read_text(errors='replace')))
    globales = set(conocidos)
    for s in lineas:
        m = ASIGNA.match(s['texto'])
        if m and m[2] == '=>':
            globales.add(re.sub(r'\s+', '', m[1]).upper())
            globales.update(nombres(m[3]))
    rutina = '(global)'
    def clave(nombre):
        return nombre if nombre in globales else rutina+'::'+nombre
    for s in lineas:
        cabecera = re.match(r'\s*(?:SUBROUTINE|(?:REAL\*8\s+)?FUNCTION|MODULE)\s+(\w+)', s['texto'], re.I)
        if cabecera:
            rutina = cabecera[1].upper()
        llamada=re.match(r'\s*CALL\s+SOLVE\s*\((.*)\)\s*$',s['texto'],re.I)
        if llamada:
            args=llamada[1].split(',')
            if len(args)==12:
                sistemas_lineales.append(dict(rutina=rutina,vector_rhs=args[8].strip().upper(),linea=s['linea']))
        m = ASIGNA.match(s['texto'])
        if not m:
            continue
        destino = clave(re.sub(r'\s+', '', m[1]).upper())
        deps = {clave(n) for n in nombres(m[3])}
        derivada = re.fullmatch(r'DERIV\(\s*(\d+)\s*\)', m[3].strip(), re.I)
        if m[2] == '=>' and derivada and rutina.startswith('SC1_DERIVS'):
            alias = m[1].strip().upper()
            indices = sorted(origen_directo.get(alias, ()))
            estado = None
            for indice in indices:
                ref = refs[indice]
                rama = ref.get('rama', '').upper()
                if rama.startswith(('L', 'C')) and alias == 'D'+rama:
                    estado = ('I' if rama.startswith('L') else 'V')+rama
                elif ref.get('nombre', '').upper() == alias and alias.startswith('D'):
                    estado = alias[1:]
            estados_integracion[int(derivada[1])] = dict(
                derivada=alias, variable=estado, referencias=indices,
                linea_generada=s['linea'])
        ecuaciones.append(dict(s, rutina=rutina, destino=destino, dependencias=sorted(deps)))
        dependencias.setdefault(destino, set()).update(deps)
        # Los POINTER del generado dan el nombre original de cada posición.
        # La relación de alias es simétrica; una asignación ordinaria no.
        if m[2] == '=>':
            for dep in deps:
                dependencias.setdefault(dep, set()).add(destino)

    # Unión conservadora de dependencias, incluso si hay ciclos algebraicos.
    # No se presenta como causalidad del fallo ni se depende del orden textual.
    inversas = {}
    for destino, deps in dependencias.items():
        for dep in deps:
            inversas.setdefault(dep, set()).add(destino)
    cola = list(conocidos)
    while cola:
        nombre = cola.pop()
        for destino in inversas.get(nombre, ()):
            antes = conocidos.setdefault(destino, set())
            nuevos = conocidos[nombre] - antes
            if nuevos:
                antes.update(nuevos)
                cola.append(destino)
    for e in ecuaciones:
        indices = set(conocidos.get(e['destino'], ()))
        for dep in e['dependencias']:
            indices.update(conocidos.get(dep, ()))
        e['referencias'] = sorted(indices)
        e['ubicacion'] = 'dependencias del fuente' if indices else 'calculo interno sin linea de fuente identificada'
    return dict(version=1, fuente=str(fuente), generado=str(generado.resolve()),
                criterio='Dependencias conservadoras; no identifica una ecuacion culpable de un fallo global.',
                referencias=refs, ecuaciones=ecuaciones, sistemas_lineales=sistemas_lineales,
                estados_integracion=estados_integracion)


def diagnostico_matriz(archivo, mapa):
    """Eliminación con pivoteo de filas sobre la matriz previa al solver.

    Conserva combinaciones de filas y vectores nulos; no adjudica por sí
    sola una causa física ni modifica el código devuelto por SCEPTRE.
    """
    lineas=archivo.read_text().splitlines()
    nombre=lineas[0]
    n,rhs_valido=map(int,lineas[1].split())
    a=[list(map(float,l.split())) for l in lineas[2:2+n]]
    b=list(map(float,lineas[2+n].split()))
    if n<1 or len(a)!=n or any(len(f)!=n for f in a) or len(b)!=n:
        raise ValueError('matriz de diagnóstico incompleta')
    if not all(math.isfinite(v) for f in a for v in f) or not all(map(math.isfinite,b)):
        raise ValueError('matriz de diagnóstico con valores no finitos')
    filas=[max(map(abs,f)) or 1. for f in a]
    a=[[v/filas[i] for v in f] for i,f in enumerate(a)]
    columnas=[max(abs(a[i][j]) for i in range(n)) or 1. for j in range(n)]
    a=[[v/columnas[j] for j,v in enumerate(f)] for f in a]
    e=[[float(i==j) for j in range(n)] for i in range(n)]
    tol=n*sys.float_info.epsilon
    pivotes=[]
    for col in range(n):
        r=len(pivotes)
        if r==n: break
        k=max(range(r,n),key=lambda i:abs(a[i][col]))
        if abs(a[k][col])<=tol: continue
        a[r],a[k]=a[k],a[r]; e[r],e[k]=e[k],e[r]
        pivote=a[r][col]
        a[r]=[v/pivote for v in a[r]]; e[r]=[v/pivote for v in e[r]]
        for i in range(n):
            if i==r: continue
            factor=a[i][col]
            a[i]=[v-factor*w for v,w in zip(a[i],a[r])]
            e[i]=[v-factor*w for v,w in zip(e[i],e[r])]
        pivotes.append(col)
    estados = {int(k): v for k, v in mapa.get('estados_integracion', {}).items()}
    es_psav = nombre in ('LINSOL PSAV', 'SOLVE PSAV')
    coordenadas = [dict(indice=i, **estados[i]) if i in estados else dict(indice=i)
                   for i in range(1,n+1)] if es_psav else []
    dependencias=[]
    for i in range(len(pivotes),n):
        escala=max(map(abs,e[i])) or 1.
        coef=[v/escala for v in e[i]]
        proyeccion=sum(c*v/f for c,v,f in zip(coef,b,filas)) if rhs_valido else None
        posiciones=[j+1 for j,c in enumerate(coef) if abs(c)>1e-6]
        referencias=set()
        if es_psav:
            for posicion in posiciones:
                referencias.update(estados.get(posicion, {}).get('referencias', ()))
        # La fase 1 escribe el RHS de SOLVE con sus índices originales.
        for sistema in mapa.get('sistemas_lineales',[]) if nombre=='SOLVE' else []:
            patron=re.compile(r'(?:::|^)'+re.escape(sistema['vector_rhs'])+r'\(0*(\d+)\)$')
            for eq in mapa['ecuaciones']:
                m=patron.search(eq['destino'])
                if eq['rutina']==sistema['rutina'] and m and int(m[1]) in posiciones:
                    referencias.update(eq['referencias'])
        dependencias.append(dict(filas=posiciones,coeficientes=coef,escala_filas=filas,
                                 proyeccion_rhs=proyeccion,referencias=sorted(referencias)))
    direcciones=[]
    for col in range(n):
        if col in pivotes: continue
        v=[0.]*n; v[col]=1.
        for i,piv in enumerate(pivotes): v[piv]=-a[i][col]
        direcciones.append([x/c for x,c in zip(v,columnas)])
    return dict(matriz=nombre,dimension=n,rango_estimado=len(pivotes),tolerancia=tol,
                rhs_valido=bool(rhs_valido),dependencias=dependencias,direcciones=direcciones,
                coordenadas=coordenadas,
                criterio='Diagnostico numerico de la matriz capturada; no prueba redundancia global no lineal.')


def imprime_diagnostico(diagnostico, mapa):
    d=diagnostico
    print(f"SCEPTRE: DIAGNOSTICO | {d['matriz']} | rango estimado {d['rango_estimado']}/{d['dimension']} | tolerancia {d['tolerancia']:.6g}",file=sys.stderr)
    for c in d.get('coordenadas', []):
        print(f"SCEPTRE: COORDENADA | fila/columna {c['indice']} | estado {c.get('variable') or 'no identificado'} | derivada {c.get('derivada') or 'no identificada'}",file=sys.stderr)
        for ref in c.get('referencias', []):
            print('SCEPTRE: ORIGEN ESTADO | '+json.dumps(mapa['referencias'][ref],ensure_ascii=False),file=sys.stderr)
    for i,g in enumerate(d['dependencias'],1):
        print(f"SCEPTRE: DEPENDENCIA | {i} | filas originales {g['filas']} | proyeccion RHS {g['proyeccion_rhs']}",file=sys.stderr)
        for ref in g['referencias']:
            print('SCEPTRE: FUENTE | '+json.dumps(mapa['referencias'][ref],ensure_ascii=False),file=sys.stderr)
        if not g['referencias']:
            print('SCEPTRE: CONTEXTO | indices de la matriz interna; sin correspondencia exacta al fuente identificada',file=sys.stderr)
    for i,v in enumerate(d['direcciones'],1):
        print(f'SCEPTRE: DIRECCION NO DETERMINADA | {i} | '+json.dumps(v),file=sys.stderr)


def main():
    p = argparse.ArgumentParser(description=__doc__)
    p.add_argument('fuente', type=Path)
    p.add_argument('generado', type=Path)
    p.add_argument('salida', type=Path)
    p.add_argument('--singularidad', type=Path, help='Analizar matriz capturada y ampliar el mapa ya generado')
    p.add_argument('--generado-final', type=Path, help='Ubicación final del Fortran si el lanzador lo traslada')
    p.add_argument('--modellib', type=Path, help='Biblioteca empleada por esta corrida de SCEPTRE')
    p.add_argument('--dato', type=Path, help='DAT ya leído, con procedencia original')
    a = p.parse_args()
    if a.singularidad:
        resultado=json.loads(a.salida.read_text())
        diagnostico=diagnostico_matriz(a.singularidad,resultado)
        resultado['singularidad']=diagnostico
        a.salida.write_text(json.dumps(resultado,ensure_ascii=False,indent=2)+'\n')
        imprime_diagnostico(diagnostico,resultado)
        return
    fuente = a.fuente.resolve()
    with tempfile.TemporaryDirectory(prefix='sceptre-origen-') as tmp:
        if a.dato:
            dato = json.loads(a.dato.read_text())
        else:
            destino = Path(tmp)/'fuente.dat'
            orden = [os.getenv('D2DATDINC', 'd2datdinc')]
            for variable, opcion in [('D2DATDINC_CONF', '-c'), ('D2DATDINC_BIB', '-b')]:
                if os.getenv(variable):
                    orden.extend([opcion, os.environ[variable]])
            if a.modellib:
                biblioteca = Path(tmp)/'biblioteca'
                biblioteca.mkdir()
                base = Path(os.getenv('D2DATDINC_BIB', '/usr/share/slex/biblioteca')).resolve()
                for nombre in ('libraryori.siru', 'rk.siru'):
                    (biblioteca/nombre).symlink_to(base/nombre)
                (biblioteca/'modellib.siru').symlink_to(a.modellib.resolve())
                orden.extend(['-b', str(biblioteca)])
            orden.extend([str(fuente), '-o', str(destino)])
            r = subprocess.run(orden, text=True, capture_output=True, timeout=60)
            if r.returncode:
                raise RuntimeError('lector de origen: '+r.stderr.strip())
            dato = json.loads(destino.read_text())
        def resolver_archivos(valor):
            if isinstance(valor, dict):
                if valor.get('archivo') and Path(valor['archivo']).exists():
                    valor['archivo'] = str(Path(valor['archivo']).resolve())
                for hijo in valor.values():
                    resolver_archivos(hijo)
            elif isinstance(valor, list):
                for hijo in valor:
                    resolver_archivos(hijo)
        resolver_archivos(dato.get('OTHERINFO', {}))
        resultado = mapa(dato, fuente, a.generado)
        if a.generado_final:
            resultado['generado'] = str(a.generado_final.resolve())
        a.salida.write_text(json.dumps(resultado, ensure_ascii=False, indent=2)+'\n')


if __name__ == '__main__':
    try:
        main()
    except (OSError, ValueError, RuntimeError, subprocess.TimeoutExpired) as e:
        raise SystemExit('sceptre-origen: '+str(e))
