#!/usr/bin/env python3
"""dia2paraplot: el PARAPLOT que pide el diagrama de Simusol, del .dia.

    dia2paraplot tanque_med.dia       escribe tanque_med.paraplot
    dia2paraplot -r DIR...            todos los .dia de esos directorios

El argumento es el diagrama de Simusol (junta-dias lo deja al lado de cada
circuito como NOMBRE.dia). Lo que se saca de ahi es su cuadro GRAFICOS: los
ejes, los titulos, los paneles y que guardar, que son lo que el .d no dice
--igual que las formas de dia2formas-- y sin lo cual el dibujo sale sin
rotulos. Un .dia sin ese cuadro no da archivo: los graficos de un circuito
que solo declara OUTPUTS los prepara simplot solo, pidiendo
'd2datdinc --graficos' (ver simplot/doc/DAT-SIMPLOT-V2.md), asi que un
.paraplot que repitiera eso no agregaria nada. En el corpus son 6 .dia de 97.

El cuadro se escribe en el PARAPLOT de hoy, que es uno solo (decision del
autor del 09/10/2026, simplot/doc/PLAN-FUNCIONAL.md: "v1 y v2 no seran dos
lenguajes entre los cuales deba elegir el usuario"). De lo que el diagrama
trae en la forma antigua se traduce lo que tiene equivalente:

  lineas GRAFTEMP = SIMULADO, 1:2      ->   lineas GRAFTEMP = T:VC4T1
  lineas GRAFICO = SIMULADO,TIEMPO:TEMP 1  ->   lineas GRAFICO = T:VCA

es decir, se quita la fuente propia --SIMULADO es implicita, es la tabla del
mismo nombre que el circuito-- y los selectores de columna, sean numeros o
nombres propios del diagrama, pasan a los nombres de columna de la tabla.
Para eso hacen falta los OUTPUTS del circuito, que da d2datdinc en
GLOBAL.outs ('T:VC4T1,VR4T1,R4T1': el tiempo es la columna 1), y el cuadro
RESULTADOS del diagrama, que trae los nombres propios en el mismo orden.
Sin el circuito al lado no se traduce nada y el cuadro se copia como esta;
los selectores por numero siguen siendo validos.

Las ordenes que el PARAPLOT unico todavia no traduce --guardar, funcion,
nomostrar, variables, unidades, selec-- se copian tal cual y no se
descartan (U2 del plan: "no descartar ordenes ni cambiar de motor
silenciosamente"); mientras no esten traducidas, simplot las atiende por su
recorrido historico. Los comentarios del cuadro se conservan.

El archivo no lleva fecha adentro: es generado y versionado, y una fecha
deja todos los archivos modificados en cada corrida sin decir nada nuevo
(pasó con los .log de siru/corpus/regenera). Cuando se genero lo dice svn.

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

AQUI = os.path.dirname(os.path.realpath(__file__))
SIRU = os.path.normpath(os.path.join(AQUI, ".."))

# las ordenes del PARAPLOT que llevan un selector de columnas que se puede
# traducir: "palabra GRAFICO = [FUENTE,] X : Y[,Z...]"
CON_SERIES = ("lineas", "puntos")

# las palabras con que empieza una orden, para saber donde termina la
# anterior: las del PARAPLOT de hoy (simplot/doc/03-paraplot.md y
# DAT-SIMPLOT-V2.md) y las historicas que el PARAPLOT unico conserva.
# "nomostrar" no lleva "=", asi que por el "=" no alcanza.
ORDENES = ("archivo", "lineas", "puntos", "titulo", "ejes", "rangox", "rangoy",
           "mostrarjuntos", "nomostrar", "guardar", "funcion", "unipri",
           "unidades", "variables", "magnitudes", "sceptrevars", "indices",
           "arch_var", "variaciones", "selec", "escala", "echo")


def lee_cuadros(archivo):
    """los cuadros del diagrama: [(titulo, contenido)], en orden.

    Un cuadro de Simusol es un objeto "UML - Object" de Dia: el titulo es su
    atributo text y el contenido su atributo attrib, los dos entre #."""
    b = open(archivo, "rb").read()
    if b[:2] == b"\x1f\x8b":
        b = gzip.decompress(b)
    t = b.decode("utf-8", "replace")
    res = []
    for m in re.finditer(r'<dia:object type="UML - Object".*?</dia:object>', t, re.S):
        c = m.group(0)
        def texto(atributo):
            s = re.search(r'name="%s">\s*<dia:composite type="text">\s*'
                          r'<dia:attribute name="string">\s*<dia:string>#(.*?)#</dia:string>'
                          % atributo, c, re.S)
            return s.group(1).strip() if s else ""
        titulo = texto("text")
        if titulo:
            res.append((titulo, texto("attrib")))
    return res


def cuadro(cuadros, *nombres):
    """el contenido del primer cuadro con uno de esos titulos (sin importar
    mayusculas)"""
    for titulo, contenido in cuadros:
        if titulo.strip().upper() in nombres:
            return contenido
    return None


def columnas_del_circuito(circuito):
    """los nombres de columna de la tabla del circuito, en orden, de
    GLOBAL.outs ('T:VC4T1,VR4T1,R4T1'); [] si no se puede"""
    arbol = os.path.join(SIRU, "slex", "d2datdinc")
    prog = os.path.join(arbol, "d2datdinc")
    cmd = ([prog, "-c", os.path.join(arbol, "d2datdinc.slex"), "-b", os.path.join(arbol, "biblioteca")]
           if os.access(prog, os.X_OK) else [shutil.which("d2datdinc") or "d2datdinc"])
    try:
        r = subprocess.run(cmd + [os.path.basename(circuito), "-o", "-"],
                           cwd=os.path.dirname(circuito) or ".",
                           capture_output=True, text=True, timeout=120)
        if r.returncode != 0:
            return []
        outs = (json.loads(r.stdout).get("GLOBAL") or {}).get("outs") or ""
    except (OSError, subprocess.TimeoutExpired, ValueError):
        return []
    tiempo, _, resto = outs.partition(":")
    # outs abrevia el tiempo "T", pero la columna de la tabla se llama TIME
    # (asi la escribe la cabecera del .simul, y es el nombre que simplot
    # busca: con "T" dice "columna inexistente o ambigua")
    tiempo = "TIME" if tiempo.strip() in ("T", "") else tiempo.strip()
    return [tiempo] + [x.strip() for x in resto.split(",") if x.strip()]


def columnas_de_la_tabla(base):
    """los nombres de columna del .simul de al lado, si esta: la primera fila
    de la cabecera que anuncia "# para Simusol: sceptrevars, variables, ..."
    Es mas fiable que deducirlos, porque es la tabla que simplot va a leer."""
    simul = base + ".simul"
    if not os.path.exists(simul):
        return []
    filas = []
    for linea in open(simul, encoding="utf-8", errors="replace"):
        if not linea.startswith("#"):
            break
        if re.search(r"para\s+Simusol\s*:", linea):
            filas = []                      # las filas de nombres vienen abajo
            continue
        filas.append(linea.lstrip("#").split())
    return filas[0] if filas else []


def nombres_propios(cuadros):
    """los nombres del cuadro RESULTADOS, en orden (separa por coma y por
    fin de renglon)"""
    c = cuadro(cuadros, "RESULTADOS")
    if not c:
        return []
    return [x.strip() for x in re.split(r"[,\n]", c) if x.strip()]


def traductor(columnas, propios):
    """de un selector del diagrama --un numero de columna desde 1, o un
    nombre propio-- al nombre de columna de la tabla"""
    if not columnas:
        return {}
    mapa = {}
    for i, col in enumerate(columnas, 1):
        mapa[str(i)] = col
    # los nombres propios van en el mismo orden que las columnas; si el
    # primero no es el tiempo, empiezan en la segunda columna
    propios = list(propios)
    if propios and propios[0].upper() in ("TIEMPO", "TIME", "T"):
        pares = zip(propios, columnas)
    else:
        pares = zip(propios, columnas[1:])
        mapa.setdefault("TIEMPO", columnas[0])
    for propio, col in pares:
        mapa[propio] = col
        mapa[propio.upper()] = col
    return mapa


def traduce_serie(valor, mapa, propia, sola):
    """el valor de una orden lineas/puntos: pasa los selectores de la fuente
    propia a nombres de columna; la fuente solo se omite cuando es la unica
    del cuadro (con una externa declarada, una serie sin nombre seria de la
    externa: el contrato de simplot/doc/DAT-SIMPLOT-V2.md)"""
    fuente, resto = "", valor
    m = re.match(r"\s*([A-Za-z_][\w ]*)\s*,\s*(.*)$", valor, re.S)
    if m and ":" in m.group(2):
        fuente, resto = m.group(1).strip(), m.group(2)
    elif ":" not in valor:
        return valor.strip()          # no es una serie: no se toca
    if fuente and fuente != propia:
        # fuente externa: no se conocen sus columnas, se deja como esta
        return "%s,%s" % (fuente, " ".join(resto.split()))
    x, _, ys = resto.partition(":")
    def nombre(s):
        s = s.strip()
        return mapa.get(s, mapa.get(s.upper(), s))
    izq = nombre(x)
    der = ",".join(nombre(y) for y in ys.split(","))
    return ("%s:%s" if sola else propia + ",%s:%s") % (izq, der)


def renglones(texto):
    """las ordenes del cuadro, una por renglon: una linea que no empieza una
    orden --no tiene "palabra ... ="-- es continuacion de la anterior, que es
    como se escriben los cuadros largos en Dia ("ejes GRAFICO = tiempo(min),"
    y en el renglon siguiente "temp(gradosC)")"""
    res = []
    for linea in texto.splitlines():
        if not linea.strip():
            continue
        primera = (re.match(r"\s*(\w+)", linea) or [None, ""])[1].lower()
        empieza = (linea.lstrip().startswith("#") or primera in ORDENES
                   or re.match(r"\s*\w+\s+[^=]*?\s*=", linea))
        if empieza or not res or res[-1].lstrip().startswith("#"):
            res.append(linea)
        else:
            res[-1] = res[-1].rstrip() + " " + linea.strip()
    return res


def paraplot_de(dia):
    """escribe NOMBRE.paraplot junto a NOMBRE.dia; devuelve (archivo,
    ordenes, traducidas) o el motivo de no escribirlo"""
    base = os.path.splitext(dia)[0]
    cuadros = lee_cuadros(dia)
    graficos = cuadro(cuadros, "GRAFICOS")
    adicionales = cuadro(cuadros, "GRAFICOS_ADICIONALES", "AGREGAR_GRAFICOS")
    if not graficos and not adicionales:
        return "el .dia no tiene cuadro GRAFICOS"
    circuito = next((base + e for e in (".d", ".ds") if os.path.exists(base + e)), None)
    columnas = columnas_de_la_tabla(base)
    if not columnas and circuito:
        columnas = columnas_del_circuito(circuito)
    mapa = traductor(columnas, nombres_propios(cuadros))
    propia = "SIMULADO"

    ordenes, traducidas = [], 0
    # si el cuadro declara otras fuentes (archivo EXPE = ...), la propia no
    # puede quedar implicita en las series
    sola = not any(re.match(r"\s*archivo\s+", l, re.I)
                   for texto in (graficos, adicionales) if texto
                   for l in renglones(texto))
    for texto in (graficos, adicionales):
        if not texto:
            continue
        for linea in renglones(texto):
            if linea.lstrip().startswith("#"):
                ordenes.append(linea.strip())
                continue
            m = re.match(r"\s*(\w+)\s+([^=]*?)\s*=\s*(.*)$", linea, re.S)
            if not m:
                ordenes.append(" ".join(linea.split()))
                continue
            orden, objeto, valor = m.group(1), m.group(2).strip(), m.group(3)
            if orden.lower() in CON_SERIES and mapa:
                nuevo = traduce_serie(valor, mapa, propia, sola)
                traducidas += nuevo != " ".join(valor.split())
                valor = nuevo
            else:
                valor = " ".join(valor.split())
            ordenes.append("%s %s = %s" % (orden, objeto, valor) if objeto
                           else "%s = %s" % (orden, valor))

    salida = base + ".paraplot"
    with open(salida, "w", encoding="utf-8") as o:
        o.write("# PARAPLOT de %s, del cuadro GRAFICOS de %s (dia2paraplot).\n"
                % (os.path.basename(base), os.path.basename(dia)))
        if columnas:
            o.write("# Columnas de la tabla %s.simul: %s\n"
                    % (os.path.basename(base), ", ".join(columnas)))
        else:
            o.write("# Sin el circuito al lado no se tradujeron los selectores de columna.\n")
        o.write("PARAPLOT\n")
        for l in ordenes:
            o.write(l + "\n")
    return salida, len(ordenes), traducidas


def main():
    a = argparse.ArgumentParser(description="El PARAPLOT que pide el cuadro GRAFICOS de un diagrama de Simusol (NOMBRE.paraplot, de NOMBRE.dia).")
    a.add_argument("dias", nargs="+", help="los .dia (con -r, directorios)")
    a.add_argument("-r", "--recorre", action="store_true", help="los argumentos son directorios: todos sus .dia")
    o = a.parse_args()
    lista = []
    if o.recorre:
        for d in o.dias:
            for raiz, dirs, archivos in os.walk(d):
                dirs[:] = sorted(x for x in dirs if x != ".svn")
                lista += [os.path.join(raiz, x) for x in sorted(archivos) if x.endswith(".dia")]
    else:
        lista = o.dias
    cuenta, escritos = {}, []
    for dia in lista:
        r = paraplot_de(dia)
        if isinstance(r, tuple):
            cuenta["con PARAPLOT"] = cuenta.get("con PARAPLOT", 0) + 1
            escritos.append(r)
            if not o.recorre:
                print("%s: %d ordenes, %d selectores traducidos" % r)
        else:
            cuenta[r] = cuenta.get(r, 0) + 1
            if not o.recorre:
                print("%s: %s" % (dia, r))
    if o.recorre:
        for s, n, t in escritos:
            print("%s: %d ordenes, %d selectores traducidos" % (s, n, t))
        print("%d .dia: %s" % (len(lista), ", ".join("%d %s" % (n, e) for e, n in sorted(cuenta.items()))))


if __name__ == "__main__":
    main()
