#!/usr/bin/env python3
"""dsa2dia: un .dia a partir de un modelo .dsa.

Cierra el triangulo de las tres formas equivalentes de editar lo mismo
(simusol/CADENA.md): el .dia se traduce al par .dsa, el informe interactivo
guarda un .dsa nuevo, y esto escribe el .dia que faltaba. Con eso el editor
web pasa a ser tambien una forma de CREAR diagramas, sin abrir Dia.

Lo que hace: lee el CIRCUITO del M --nombre, modelo, nodos y valor de cada
rama-- y escribe un diagrama con sus nodos, sus elementos, las lineas que
los conectan DE VERDAD (conexiones logicas, no solo coordenadas, que si no
el diagrama no se podria volver a traducir) y los cuadros de texto con los
datos y los resultados del DU.

El acomodo es propio y simple: los nodos en una fila y los elementos entre
ellos. No pretende ser bonito --Dia es para eso-- sino correcto: las formas,
las conexiones y los textos. netlistsvg, que usa dibuja, calcula un acomodo
mejor pero no da las posiciones, solo el SVG ya dibujado.

HASTA DONDE LLEGA (20/11/2026). El circulo CIERRA: el .dia que escribe se
vuelve a traducir y da el mismo circuito. Comprobado con el tanque del
autor, .dsa -> .dia -> .dsa: el traductor termina con 0 y recupera las
cuatro ramas, tres de ellas IDENTICAS --E3, R5 y CA, con sus nodos y sus
valores-- y Dia abre el archivo sin quejas.

Lo que todavia no vuelve igual es un valor con llamada a funcion: el
'X1(500*XTABLE(T1,TIME))' de la fuente vuelve como 'X1(X1(500*T1(TIME)))'.
Es el mismo problema que el de las unidades pero en las formulas: el .dsa
guarda la forma interna --el X1 que envuelve, el XTABLE con su tabla-- y en
el dibujo eso se escribe de otra manera ('500 * TABLA 1(TIEMPO)'), asi que
hay que traducirla de vuelta. Falta ese mapa.

Lo que quedo resuelto de la mecanica del formato, averiguado del diagrama
del autor y de los .shape instalados:

  - la conexion LOGICA, que es lo que hace que un diagrama se pueda volver
    a traducir: la linea lleva <dia:connections> con un
    <dia:connection handle="0|1" to="IDOBJETO" connection="INDICE"/>;
  - los indices de conexion salen de los .shape, donde el ORDEN de cada
    <point> es su indice: la hconductiva declara dos --0 izquierda, 1
    derecha-- y el acumulador y la fuente uno solo;
  - una forma de un solo punto se conecta al nodo QUE NO ES TIERRA: en lo
    termico una fuente toca un nodo y su otro lado es el ambiente;
  - un nodo es una caja de Dia y se conecta por su centro, el indice 8;
  - el texto de un elemento es SOLO SU NUMERO, y se saca UNA letra: la del
    tipo. 'R5' se dibuja como un 5, 'CA' como una A;
  - LA LETRA LA DA LA FORMA: la hconductiva es la R, el acumulador la C,
    la fuente la E y el flujo la J;
  - un cuadro de texto es un 'UML - Object', con el nombre del cuadro en su
    atributo 'text' y el contenido en 'attrib', y los dos son composites de
    texto, no cadenas sueltas;
  - cada dato va en SU cuadro: el valor de los elementos en DATOS, las
    condiciones iniciales en INICIALES, y el tiempo en TIEMPO, que lleva
    valor y unidad ('6 horas') y no asignaciones;
  - los valores se escriben en la unidad DEL DIBUJO, no en la interna: el
    grado Celsius es afin, asi que 291.15 K se escriben como 18.

Uso:
    dsa2dia MODELO.M.dsa [-o SALIDA.dia]

Copyright (C) Diego Saravia <dsa@unsa.edu.ar>
GPL version 3 o posterior.
"""

import argparse
import os
import re
import sys
from xml.sax.saxutils import escape

# LA FORMA DE CADA MODELO DE ELEMENTO, y donde se conecta.
#
# 'puntos' son los indices de los puntos de conexion de la forma, en el orden
# de los nodos de la rama: la hconductiva declara dos --0 a la izquierda, 1 a
# la derecha-- y el acumulador y la fuente uno solo, asi que su segundo nodo
# no se dibuja (en lo termico es el ambiente). Los indices salen de los
# .shape instalados, donde el orden de <point> ES el indice.
FORMAS = {
    'Resistencia':            ('Termico - hconductiva', [0, 1]),
    'ResistenciaTermica':     ('Termico - hconductiva', [0, 1]),
    'Condensador':            ('Termico - acumulador',  [0]),
    # una fuente de FLUJO es la forma del flujo --da la letra J-- y una
    # fuente de temperatura es la fuente --da la E--: la letra de la rama la
    # pone la forma, no el texto
    'FuenteCorriente':        ('Termico - flujoi',      [0, 1]),
    'FuenteTensionSceptre':   ('Termico - fuente',      [0]),
}
FORMA_NODO = 'Termico - nodo'
# una caja de Dia tiene nueve puntos y el 8 es el centro: es el que usan los
# diagramas que escribe Dia para conectar a un nodo
PUNTO_NODO = 8

ANCHO = 1.55          # el lado de un nodo, como lo escribe Dia
ALTO_ELEM = 1.0
PASO_X = 5.0
FILA_NODOS = 1.5
FILA_ELEM = 6.0


def leer(ruta):
    with open(ruta, encoding='utf-8') as f:
        return f.read()


def ramas_del_m(texto):
    """[(nombre, modelo, [nodos], valor)] del bloque CIRCUITO."""
    ramas, dentro = [], False
    for linea in texto.splitlines():
        if not dentro:
            dentro = re.match(r'\s*CIRCUITO\s*$', linea, re.I) is not None
            continue
        if re.match(r'\s*FIN\s*$', linea, re.I):
            break
        if re.match(r'\s*(#|$)', linea):
            continue
        m = re.match(r'\s*([^\s:]+)\s*:\s*([^,]+?)\s*,\s*(.*?)\s*=\s*(.*?)\s*$', linea)
        if not m:
            continue
        nodos = [x.strip() for x in m.group(3).split(',') if x.strip()]
        ramas.append((m.group(1), m.group(2), nodos, m.group(4)))
    return ramas


def variable_de_integracion(texto):
    for linea in texto.splitlines():
        m = re.match(r'\s*VARIABLE_INTEGRACION\s*:\s*(\S+)\s*$', linea, re.I)
        if m:
            return m.group(1)
    return ''


def unidades_del_du(texto):
    """NOMBRE -> unidad, del bloque UNIDADES del DU. El traductor lo escribe
    derivado de la hoja (simusol, r9344): 'VCA: tempC, temperatura'."""
    u, dentro = {}, False
    for linea in texto.splitlines():
        if not dentro:
            dentro = re.match(r'\s*UNIDADES\s*$', linea, re.I) is not None
            continue
        if re.match(r'\s*FIN\s*$', linea, re.I):
            break
        m = re.match(r'\s*"?([^\s:"]+)\s*:\s*([^,"]+)', linea)
        if m:
            u[m.group(1)] = m.group(2).strip()
    return u


def valor_para_el_dibujo(valor, unidad):
    """El valor como lo escribe un diagrama: un numero, sin unidad.
    En el .dsa los valores estan en la unidad interna --el DU dice
    'VCA = 291.15 K'-- y en el dibujo la unidad la implica la hoja, asi que
    hay que volver a la del dibujo. El unico caso que cambia el numero es el
    grado Celsius, que es una unidad AFIN: 291.15 K son 18 C. El traductor,
    ademas, evalua el contenido del cuadro como una expresion, asi que una
    unidad escrita al lado lo corta."""
    v = valor.strip()
    m = re.match(r'^(-?[0-9.eE+-]+)\s*([A-Za-z]+)?$', v)
    if not m:
        return v                      # una expresion: va tal cual
    numero, un = m.group(1), (m.group(2) or '')
    if (unidad or '').lower() in ('tempc', 'degc', 'celsius') and un in ('K', ''):
        try:
            return '%g' % (float(numero) - 273.15)
        except ValueError:
            return v
    return numero


def bloque_del_du(texto, nombre):
    """los renglones de un bloque del DU, sin el encabezado ni el FIN."""
    salida, dentro = [], False
    for linea in texto.splitlines():
        if not dentro:
            dentro = re.match(r'\s*%s\s*$' % nombre, linea, re.I) is not None
            continue
        if re.match(r'\s*FIN\s*$', linea, re.I):
            break
        if linea.strip():
            salida.append(linea.strip())
    return salida


def punto(x, y):
    return '%.4f,%.4f' % (x, y)


def attr_punto(nombre, x, y):
    return ('      <dia:attribute name="%s">\n'
            '        <dia:point val="%s"/>\n'
            '      </dia:attribute>\n' % (nombre, punto(x, y)))


def attr_real(nombre, v):
    return ('      <dia:attribute name="%s">\n'
            '        <dia:real val="%s"/>\n'
            '      </dia:attribute>\n' % (nombre, v))


def attr_texto(texto, x, y, nombre='text'):
    """un atributo de texto de Dia: un composite type="text" con la cadena
    entre almohadillas. Asi lo escribe Dia y asi lo busca el traductor, que
    por eso no leia una cadena suelta. Los saltos de linea van de verdad,
    no escapados."""
    return ('      <dia:attribute name="%s">\n' % nombre +
            '        <dia:composite type="text">\n'
            '          <dia:attribute name="string">\n'
            '            <dia:string>#%s#</dia:string>\n'
            '          </dia:attribute>\n'
            '          <dia:attribute name="font">\n'
            '            <dia:font family="courier new" style="0" name="Courier"/>\n'
            '          </dia:attribute>\n'
            '          <dia:attribute name="height">\n'
            '            <dia:real val="0.8"/>\n'
            '          </dia:attribute>\n'
            '          <dia:attribute name="pos">\n'
            '            <dia:point val="%s"/>\n'
            '          </dia:attribute>\n'
            '          <dia:attribute name="color">\n'
            '            <dia:color val="#000000ff"/>\n'
            '          </dia:attribute>\n'
            '          <dia:attribute name="alignment">\n'
            '            <dia:enum val="1"/>\n'
            '          </dia:attribute>\n'
            '        </dia:composite>\n'
            '      </dia:attribute>\n') % (escape(texto), punto(x, y))


def objeto_forma(tipo, ident, x, y, ancho, alto, texto):
    s = '    <dia:object type="%s" version="1" id="%s">\n' % (escape(tipo), ident)
    s += attr_punto('obj_pos', x, y)
    s += ('      <dia:attribute name="obj_bb">\n'
          '        <dia:rectangle val="%s;%s"/>\n'
          '      </dia:attribute>\n' % (punto(x, y), punto(x + ancho, y + alto)))
    s += attr_punto('elem_corner', x, y)
    s += attr_real('elem_width', ancho)
    s += attr_real('elem_height', alto)
    s += attr_texto(texto, x + ancho / 2, y + alto / 2)
    s += '    </dia:object>\n'
    return s


def objeto_caja(ident, x, y, nombre, renglones):
    """un cuadro de texto: el 'UML - Object' que usa Simusol, con el nombre
    del cuadro en su titulo y el contenido en sus atributos."""
    cuerpo = '\n'.join(renglones)
    s = '    <dia:object type="UML - Object" version="0" id="%s">\n' % ident
    s += attr_punto('obj_pos', x, y)
    s += ('      <dia:attribute name="obj_bb">\n'
          '        <dia:rectangle val="%s;%s"/>\n'
          '      </dia:attribute>\n' % (punto(x, y), punto(x + 8, y + 2 + 0.6 * len(renglones))))
    s += attr_punto('elem_corner', x, y)
    s += attr_real('elem_width', 8.0)
    s += attr_real('elem_height', 2.0 + 0.6 * len(renglones))
    s += attr_texto(nombre, x + 1, y + 0.8)
    s += ('      <dia:attribute name="stereotype">\n'
          '        <dia:string>##</dia:string>\n'
          '      </dia:attribute>\n')
    s += attr_texto(cuerpo, x + 1, y + 1.6, 'attrib')
    s += '    </dia:object>\n'
    return s


def linea(ident, desde, hasta, a_obj, a_pto, b_obj, b_pto):
    x1, y1 = desde
    x2, y2 = hasta
    medio = (y1 + y2) / 2
    s = '    <dia:object type="Standard - ZigZagLine" version="1" id="%s">\n' % ident
    s += attr_punto('obj_pos', x1, y1)
    s += ('      <dia:attribute name="obj_bb">\n'
          '        <dia:rectangle val="%s;%s"/>\n'
          '      </dia:attribute>\n'
          % (punto(min(x1, x2) - 0.1, min(y1, y2) - 0.1),
             punto(max(x1, x2) + 0.1, max(y1, y2) + 0.1)))
    s += ('      <dia:attribute name="orth_points">\n'
          '        <dia:point val="%s"/>\n'
          '        <dia:point val="%s"/>\n'
          '        <dia:point val="%s"/>\n'
          '        <dia:point val="%s"/>\n'
          '      </dia:attribute>\n'
          % (punto(x1, y1), punto(x1, medio), punto(x2, medio), punto(x2, y2)))
    s += ('      <dia:attribute name="orth_orient">\n'
          '        <dia:enum val="1"/>\n'
          '        <dia:enum val="0"/>\n'
          '        <dia:enum val="1"/>\n'
          '      </dia:attribute>\n')
    s += ('      <dia:connections>\n'
          '        <dia:connection handle="0" to="%s" connection="%d"/>\n'
          '        <dia:connection handle="1" to="%s" connection="%d"/>\n'
          '      </dia:connections>\n' % (a_obj, a_pto, b_obj, b_pto))
    s += '    </dia:object>\n'
    return s


def dia_de(m_texto, du_texto):
    ramas = ramas_del_m(m_texto)
    if not ramas:
        raise SystemExit('dsa2dia: el modelo no trae un bloque CIRCUITO con ramas')

    # los nodos, en el orden en que aparecen
    nodos, visto = [], set()
    for _, _, ns, _ in ramas:
        for n in ns:
            if n not in visto:
                visto.add(n)
                nodos.append(n)

    ident = [0]

    def nuevo_id():
        ident[0] += 1
        return 'O%d' % ident[0]

    cuerpo = ''
    pos_nodo, id_nodo = {}, {}
    for i, n in enumerate(nodos):
        x = 2.0 + i * PASO_X
        id_nodo[n] = nuevo_id()
        pos_nodo[n] = (x + ANCHO / 2, FILA_NODOS + ANCHO / 2)
        cuerpo += objeto_forma(FORMA_NODO, id_nodo[n], x, FILA_NODOS, ANCHO, ANCHO, n)

    lineas = ''
    for k, (nombre, modelo, ns, valor) in enumerate(ramas):
        forma, puntos = FORMAS.get(modelo, ('Termico - hconductiva', [0, 1]))
        # el elemento, entre sus nodos
        xs = [pos_nodo[n][0] for n in ns if n in pos_nodo]
        x = (sum(xs) / len(xs) - ANCHO) if xs else 2.0 + k * PASO_X
        y = FILA_ELEM + (k % 2) * 2.5
        ide = nuevo_id()
        # EL TEXTO DE UN ELEMENTO ES SOLO SU NUMERO: la letra la da la
        # forma --una hconductiva es la R-- y asi lo escribe Dia. El valor
        # no va en el dibujo sino en el cuadro DATOS.
        cuerpo += objeto_forma(forma, ide, x, y, 2.0, ALTO_ELEM,
                               re.sub(r'^[A-Za-z]', '', nombre) or nombre)
        # UNA FORMA DE UN SOLO PUNTO SE CONECTA AL NODO QUE NO ES TIERRA:
        # en un circuito termico una fuente toca un nodo y su otro lado es
        # el ambiente, que el modelo escribe como GND. Conectarla al primero
        # de la lista dejaba 'E3: ..., GND, GND' donde iba 'GND, 2'.
        orden_nodos = list(ns)
        if len(puntos) == 1 and len(ns) > 1:
            orden_nodos = [n for n in ns if n.upper() != 'GND'] or ns
        for j, n in enumerate(orden_nodos):
            if j >= len(puntos) or n not in id_nodo:
                continue
            lineas += linea(nuevo_id(), (x + 1.0, y), pos_nodo[n],
                            ide, puntos[j], id_nodo[n], PUNTO_NODO)

    # los cuadros de texto: lo que el DU dice
    ycaja = FILA_ELEM + 6.0
    # CADA DATO EN EL CUADRO QUE LE CORRESPONDE. El traductor no acepta
    # cualquier cosa en DATOS: ahi van los valores de los elementos, y lo
    # demas tiene su cuadro. Un TIEMPOFINAL en DATOS lo rechaza pidiendo que
    # empiece con P, porque ahi solo entiende parametros y elementos.
    #
    #   TIEMPO      la variable de integracion y su valor final
    #   INICIALES   las condiciones iniciales: la V, la I o la Q de una rama
    #   DATOS       el valor de cada elemento
    #   RESULTADOS  lo que se informa
    datos_du = bloque_del_du(du_texto, 'DATOS')
    vi = variable_de_integracion(m_texto)
    cajas = {'TIEMPO': [], 'INICIALES': [],
             'DATOS': ['%s = %s' % (r[0], r[3]) for r in ramas],
             'RESULTADOS': bloque_del_du(du_texto, 'RESULTADOS')}
    nombres_rama = set(r[0] for r in ramas)
    unidades = unidades_del_du(du_texto)
    for ren in datos_du:          # 'linea' es el nombre de la funcion de abajo
        m = re.match(r'([^\s=]+)\s*=\s*(.*)$', ren)
        if not m:
            continue
        n = m.group(1)
        ren = '%s = %s' % (n, valor_para_el_dibujo(m.group(2), unidades.get(n)))
        if n.upper() == 'TIEMPOFINAL':
            # EL CUADRO TIEMPO LLEVA VALOR Y UNIDAD, no asignaciones: en un
            # diagrama dice '6 horas'. El traductor pide la unidad, y en el
            # .dsa el valor esta en la interna, que para el tiempo es el
            # segundo.
            cajas['TIEMPO'].append('%s segundos'
                                   % valor_para_el_dibujo(m.group(2), None))
        elif n == vi:
            continue              # el arranque es 0 y el cuadro no lo lleva
        elif n[:1] in 'VIQ' and n[1:] in nombres_rama:
            cajas['INICIALES'].append(ren)
        else:
            cajas['DATOS'].append(ren)
    for nombre in ('TIEMPO', 'INICIALES', 'DATOS', 'RESULTADOS'):
        renglones = cajas[nombre]
        if not renglones:
            continue
        cuerpo += objeto_caja(nuevo_id(), 2.0, ycaja, nombre, renglones)
        ycaja += 2.0 + 0.6 * len(renglones) + 1.0

    return ('<?xml version="1.0" encoding="UTF-8"?>\n'
            '<dia:diagram xmlns:dia="http://www.lysator.liu.se/~alla/dia/">\n'
            '  <dia:layer name="Fondo" visible="true" active="true">\n'
            + cuerpo + lineas +
            '  </dia:layer>\n'
            '</dia:diagram>\n')


def main():
    p = argparse.ArgumentParser(description='Un .dia a partir de un modelo .dsa.')
    p.add_argument('modelo', help='el M.dsa; el DU.dsa se busca al lado')
    p.add_argument('-o', '--salida', help='el .dia (por omision, el nombre del modelo)')
    a = p.parse_args()

    m = a.modelo
    du = re.sub(r'\.M\.dsa$', '.DU.dsa', m)
    if du == m:
        du = None
    salida = a.salida or re.sub(r'(\.M)?\.dsa$', '', m) + '.dia'
    if os.path.exists(salida):
        raise SystemExit('dsa2dia: ya existe %s' % salida)

    m_texto = leer(m)
    du_texto = leer(du) if du and os.path.exists(du) else ''
    with open(salida, 'w', encoding='utf-8') as f:
        f.write(dia_de(m_texto, du_texto))
    print(salida)


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