HYTOS

# coding: utf-8

""" This is Equipment module """

from xml.etree.ElementTree import Element, SubElement, dump, ElementTree, parse, tostring

from PyQt5.QtWidgets import *

from PyQt5.QtGui import *

from PyQt5.QtCore import *

from .Extent import Extent

from .Presentation import Presentation

from .Shape import Point, Line as DEXPI_Line, ConnectionPoints, GenericAttributes, BsplineCurve

class PipingComponent:

    ITEMS = 0

    def __init__(self):

        pass

    @staticmethod

    def to_transform(matrix: str) -> QTransform:

        """convert given value to transform"""

        import sys

        import re

        res = None

        try:

            if 'matrix' in matrix:

                _str = matrix[len('matrix('):-1]

                tokens = _str.split(',')

                res = QTransform(float(tokens[0]), float(tokens[1]),

                                 float(tokens[2]), float(tokens[3]),

                                 float(tokens[4]), float(tokens[5]))

            else:

                float_re = '[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?'

                translate_trans = None

                if 'translate' in matrix:

                    match = re.search(f"translate\({float_re},{float_re}\)", matrix)

                    if match:

                        _str = match.group()[len('translate('):-1]

                        tokens = _str.split(',')

                        translate_trans = QTransform()

                        translate_trans.translate(float(tokens[0]), float(tokens[1]))

                scale_trans = None

                if 'scale' in matrix:

                    match = re.search(f"scale\({float_re},{float_re}\)", matrix)

                    if match:

                        _str = match.group()[len('scale('):-1]

                        tokens = _str.split(',')

                        scale_trans = QTransform()

                        scale_trans.scale(float(tokens[0]), float(tokens[1]))

                if translate_trans and scale_trans:

                    res = scale_trans * translate_trans

                elif translate_trans:

                    res = translate_trans

                elif scale_trans:

                    res = scale_trans

        except Exception as ex:

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            print(message)

        return res

    @staticmethod

    def apply_transform(trans: QTransform, pos: complex) -> complex:

        """transform given pos and then return the result"""

        res = trans.map(QPointF(pos.real, pos.imag))

        return complex(res.x(), res.y())

    @staticmethod

    def to_xml(item) -> Element:

        """return element for equipment"""

        import sys

        from svg.path import Path, Line, Arc, CubicBezier, QuadraticBezier, parse_path

        from svg.path.path import Move

        try:

            node = Element('PipingComponent')

            node.attrib['ID'] = f"XPC_{PipingComponent.ITEMS}"

            PipingComponent.ITEMS += 1

            node.attrib['ComponentClass'] = ''

            node.attrib['ComponentName'] = ''

            node.attrib['ComponentType'] = 'Explicit'

            node.attrib['Status'] = 'Current'

            Presentation.to_xml(node, layer='0', color='0', line_type='0', line_weight=1, r=0, g=0, b=0)

            Extent.to_xml(node, item=item)

            _node = SubElement(node, 'Position')

            pt = item.pos()

            _node.append(Point.to_xml('Location', pt.x(), pt.y()))

            _node.append(Point.to_xml('Axis', 0, 0, 1))

            _node.append(Point.to_xml('Reference', 1, 0, 0))

            node.append(Point.to_xml('Scale', 1, 1, 1))

            _node = SubElement(node, 'PersistentID')

            _node.attrib['Identifier'] = str(item.uid)

            _node.attrib['Context'] = 'ID2'

            svg = item.to_svg(parent=None)

            matrix_trans = None

            if 'transform' in svg[0].attrib:

                matrix_trans = PipingComponent.to_transform(svg[0].attrib['transform'])

            paths = svg[0].findall('path')

            for path in paths:

                _trans = PipingComponent.to_transform(path.attrib['transform'])

                trans = _trans * matrix_trans

                path_ele = parse_path(path.attrib['d'])

                for idx, ele in enumerate(path_ele):

                    if type(ele) is Move:

                        continue

                    elif type(ele) is Line:

                        line = DEXPI_Line(PipingComponent.apply_transform(trans, ele.start),

                                          PipingComponent.apply_transform(trans, ele.end))

                        node.append(line.to_xml())

                    elif type(ele) is Arc:

                        continue

                    elif type(ele) is CubicBezier:

                        bspline_curve_node = BsplineCurve.to_xml(controls=[PipingComponent.apply_transform(trans, ele.start),

                                                                           PipingComponent.apply_transform(trans, ele.control1),

                                                                           PipingComponent.apply_transform(trans, ele.control2),

                                                                           PipingComponent.apply_transform(trans, ele.end)],

                                                                 _type='BsplineCurve', knots=[])

                        node.append(bspline_curve_node)

                    elif type(ele) is QuadraticBezier:

                        continue

                    else:

                        continue

            generic_attributes = GenericAttributes(item)

            _attr_node = generic_attributes.to_xml()

            if _attr_node:

                node.append(_attr_node)

            connection_points_node = ConnectionPoints(item.connectors)

            _conn_node = connection_points_node.to_xml()

            if _conn_node:

                node.append(_conn_node)

            return node

        except Exception as ex:

            message = f"error occurred({repr(ex)}) in {sys.exc_info()[-1].tb_frame.f_code.co_filename}:" \

                      f"{sys.exc_info()[-1].tb_lineno}"

            print(message)

class Nozzle:

    def __init__(self):

        pass

    @staticmethod

    def to_xml(item) -> Element:

        """return element for nozzle"""

        node = Element('Nozzle')

        node.attrib['ID'] = ''

        node.attrib['TagName'] = ''

        node.attrib['ComponentClass'] = 'Nozzle'

        node.attrib['ComponentName'] = ''

        node.attrib['ComponentType'] = 'Explicit'

        node.attrib['Status'] = 'Current'

        Presentation.to_xml(node, layer='30', color='0', line_type='0', line_weight=0.1, r=0, g=0, b=0)

        return node

from .PipingComponent import PipingComponent

        from SymbolSvgItem import SymbolSvgItem

            elif issubclass(type(item), SymbolSvgItem):

                comp_node = PipingComponent.to_xml(item)

                if comp_node:

                    node.append(comp_node)