HYTOS

# coding: utf-8

""" This is Load command module """

import os.path

import sys

from enum import Enum

import uuid

from PyQt5.QtCore import *

from PyQt5.QtWidgets import *

from PyQt5.QtGui import *

from AppDocData import AppDocData

from AbstractCommand import AbstractCommand

from EngineeringAbstractItem import QEngineeringAbstractItem

from EngineeringPolylineItem import QEngineeringPolylineItem

from EngineeringLineItem import QEngineeringLineItem

from SymbolSvgItem import SymbolSvgItem

from GraphicsBoundingBoxItem import QGraphicsBoundingBoxItem

from EngineeringTextItem import QEngineeringTextItem

from EngineeringLineNoTextItem import QEngineeringLineNoTextItem

from EngineeringNoteItem import QEngineeringNoteItem

from QEngineeringSizeTextItem import QEngineeringSizeTextItem

from EngineeringUnknownItem import QEngineeringUnknownItem

from EngineeringEquipmentItem import QEngineeringEquipmentItem

from EngineeringInstrumentItem import QEngineeringInstrumentItem

from EngineeringSpecBreakItem import QEngineeringSpecBreakItem

from EngineeringErrorItem import QEngineeringErrorItem

from EngineeringVendorItem import QEngineeringVendorItem

from EngineeringEndBreakItem import QEngineeringEndBreakItem

from EngineeringReducerItem import QEngineeringReducerItem

from EngineeringFlowMarkItem import QEngineeringFlowMarkItem

from EngineeringRunItem import QEngineeringRunItem

from QEngineeringTrimLineNoTextItem import QEngineeringTrimLineNoTextItem

from QEngineeringInstLineNoTextItem import QEngineeringInstLineNoTextItem

class LoadCommand(AbstractCommand):

    display_message = pyqtSignal(Enum, str)

    set_maximum = pyqtSignal(int)

    show_progress = pyqtSignal(int)

    def __init__(self):

        super(LoadCommand, self).__init__(None)

    def execute(self, params, symbol=True, text=True, line=True, unknown=True, package=True, update=True):

        """load data form xml file for database"""

        from datetime import datetime

        from App import App

        from AppDocData import AppDocData

        from AppDocData import MessageType

        import concurrent.futures as futures

        # Yield successive n-sized

        # chunks from l.

        def divide_chunks(l, n):

            # looping till length l

            for i in range(0, len(l), n):

                yield l[i:i + n]

        def update_items(items):

            for item in items:

                # binding items

                item.owner

                for connector in item.connectors:

                    connector.connectedItem

            return items

        app_doc_data = AppDocData.instance()

        try:

            drawing, scene = params[0], params[1]

            file_name = os.path.splitext(os.path.basename(drawing.file_path))[0]

            path = os.path.join(app_doc_data.getCurrentProject().getTempPath(), file_name + '.xml')

            configs = app_doc_data.getConfigs('Data Load', 'Xml First')

            if configs and int(configs[0].value) >= 1 and os.path.isfile(path):

                value = self.load_data_from_xml(drawing, scene, symbol, text, line, unknown, package)

            elif configs and int(configs[0].value) <= 1:

                value = self.load_data_from_database(drawing, scene, symbol, text, line, unknown, package)

            """update items"""

            if update:

                _items = [_item for _item in scene.items() if hasattr(_item, 'owner') or hasattr(_item, 'connectors')]

                if _items:

                    items = divide_chunks(_items, App.THREAD_MAX_WORKER if len(_items) > App.THREAD_MAX_WORKER else

                    len(_items))

                    with futures.ThreadPoolExecutor(max_workers=App.THREAD_MAX_WORKER) as pool:

                        future_items = {pool.submit(update_items, _items): _items for _items in items}

                        for future in futures.as_completed(future_items):

                            _items = future.result()

                            value = value + len(_items)

                            self.show_progress.emit(value)

        except Exception as ex:

            from AppDocData import MessageType

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

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

            self.display_message.emit(MessageType.Error, message)

        finally:

            app_doc_data.clearTempDBData()

    def load_data_from_xml(self, drawing, scene, symbol, text, line, unknown, package) -> int:

        item_dic = {}

        def find_item(scene, uid):

            items = [item for item in scene.items() if hasattr(item, 'uid') and str(item.uid) == str(uid)]

            return items[0] if items else None

        def find_items(scene, uids, lineNo=None):

            nonlocal item_dic

            uids = [str(uid) for uid in uids]

            if lineNo and str(lineNo.uid) in item_dic:

                items = [(item, uids.index(str(item.uid))) for item in [_item for _item in item_dic[str(lineNo.uid)] if str(_item.uid) in uids]]

            else:

                items = [(item, uids.index(str(item.uid))) for item in scene.items() if hasattr(item, 'uid') and str(item.uid) in uids]

            items = [item[0] for item in sorted(items, key= lambda param:param[1])]

            return items

        def add_item_dict(item):

            nonlocal item_dic

            if item._owner and str(item._owner) in item_dic:

                item_dic[str(item._owner)].append(item)

            elif item._owner:

                item_dic[str(item._owner)] = [item]

        import concurrent.futures as futures

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

        from App import App

        from EngineeringGraphicsLineItem import QEngineeringGraphicsLineItem

        app_doc_data = AppDocData.instance()

        value = 0

        try:

            file_name = os.path.splitext(os.path.basename(drawing.file_path))[0]

            path = os.path.join(app_doc_data.getCurrentProject().getTempPath(), file_name + '.xml')

            scene.blockSignals(True)

            symbols = []

            lines = []

            xml = parse(path)

            root = xml.getroot()

            maxValue = 0

            if symbol:

                maxValue = maxValue + len(list(root.iter('SYMBOL'))) - \

                           len(list(root.iterfind('LINENOS/LINE_NO/RUN/SYMBOL'))) - \

                           len(list(root.iterfind('TRIMLINENOS/TRIM_LINE_NO/RUN/SYMBOL')))

            if text:

                maxValue = maxValue + len(list(root.iterfind('TEXTINFOS/ATTRIBUTE')))

                maxValue = maxValue + len(list(root.iterfind('NOTES/ATTRIBUTE')))

                maxValue = maxValue + len(list(root.iter('LINE_NO')))

                maxValue = maxValue + len(list(root.iter('TRIM_LINE_NO')))

            if line:

                maxValue = maxValue + len(list(root.iter('LINE'))) - \

                           len(list(root.iterfind('LINENOS/LINE_NO/RUN/LINE'))) - \

                           len(list(root.iterfind('TRIMLINENOS/TRIM_LINE_NO/RUN/LINE')))

                maxValue = maxValue + len(list(root.iter('GRAPHICS_LINE')))

            if unknown:

                maxValue = maxValue + len(list(root.iter('UNKNOWN')))

            maxValue *= 2

            self.set_maximum.emit(maxValue) if maxValue > 0 else None

            if symbol:

                for symbol in root.find('SYMBOLS').iter('SYMBOL'):

                    item = SymbolSvgItem.fromXml(symbol)

                    if item is not None:

                        symbols.append(item)

                        #app_doc_data.symbols.append(item)

                        item.addSvgItemToScene(scene)

                        add_item_dict(item)

                    else:

                        pt = [float(x) for x in symbol.find('LOCATION').text.split(',')]

                        size = [float(x) for x in symbol.find('SIZE').text.split(',')]

                        angle = float(symbol.find('ANGLE').text)

                        item = QGraphicsBoundingBoxItem(pt[0], pt[1], size[0], size[1])

                        item.isSymbol = True

                        item.angle = angle

                        item.setPen(QPen(Qt.red, 5, Qt.SolidLine))

                        scene.addItem(item)

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

            if text:

                # parse texts

                for text in root.find('TEXTINFOS').iter('ATTRIBUTE'):

                    item = QEngineeringTextItem.fromXml(text)

                    if item is not None:

                        uid = text.find('UID')

                        attributeValue = text.find('ATTRIBUTEVALUE')

                        name = text.find('NAME').text

                        item.addTextItemToScene(scene)

                        if name == 'TEXT':

                            if uid is not None and attributeValue is not None:

                                item.uid = uid.text

                                item.attribute = attributeValue.text

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

                # note

                for text in root.find('NOTES').iter('ATTRIBUTE'):

                    item = QEngineeringTextItem.fromXml(text)

                    if item is not None:

                        uid = text.find('UID')

                        attributeValue = text.find('ATTRIBUTEVALUE')

                        name = text.find('NAME').text

                        item.addTextItemToScene(scene)

                        if name == 'NOTE':

                            if uid is not None:

                                item.uid = uid.text

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

            if line:

                for line in root.find('LINEINFOS').iter('LINE'):

                    item = QEngineeringLineItem.fromXml(line)

                    if item:

                        scene.addItem(item)

                        lines.append(item)

                        add_item_dict(item)

                    value = value + 1

                    self.show_progress.emit(value)

                for line in root.find('LINEINFOS').iter('GRAPHICS_LINE'):

                    item = QEngineeringGraphicsLineItem.fromXml(line)

                    if item:

                        scene.addItem(item)

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

            if unknown:

                for unknown in root.iter('UNKNOWN'):

                    item = QEngineeringUnknownItem.fromXml(unknown)

                    if item is not None:

                        scene.addItem(item)

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

            if text:

                for line_no_node in root.find('LINENOS').iter('LINE_NO'):

                    line_no = QEngineeringLineNoTextItem.fromXml(line_no_node)

                    if line_no is None: continue

                    line_no.addTextItemToScene(scene)

                    if type(line_no) is not QEngineeringLineNoTextItem: continue

                    if symbol and line:

                        runs_node = line_no_node.findall('RUN')

                        if runs_node is None: continue

                        for run_node in runs_node:

                            line_run = QEngineeringRunItem()

                            uids = [child_node.find('UID').text for child_node in run_node]

                            #for child_node in run_node:

                            #    uidElement = child_node.find('UID')

                            #    if uidElement is not None:

                            #        uid = uidElement.text

                            #        uids.append(uid)

                            #        '''

                            #        run_item = find_item(scene, uid)

                            #        if run_item is not None:

                            #            run_item._owner = line_no

                            #            line_run.items.append(run_item)

                            #        '''

                            #run_items = find_items(scene, uids)

                            run_items = find_items(scene, uids, line_no)

                            for run_item in run_items:

                                run_item._owner = line_no

                                line_run.items.append(run_item)

                            line_run.owner = line_no

                            line_no.runs.append(line_run)

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

                for trimLineNo in root.iter('TRIM_LINE_NO'):

                    line_no = QEngineeringTrimLineNoTextItem()

                    line_no.uid = uuid.UUID(trimLineNo.find('UID').text)

                    if symbol and line:

                        runs_node = trimLineNo.findall('RUN')

                        if runs_node is None: continue

                        for run in runs_node:

                            line_run = QEngineeringRunItem()

                            uids = [child.find('UID').text for child in run]

                            #for child in run:

                            #    uidElement = child.find('UID')

                            #    if uidElement is not None:

                            #        uid = uidElement.text

                            #        uids.append(uid)

                            #        '''

                            #        run_item = find_item(scene, uid)

                            #        if run_item is not None:

                            #            run_item.owner = line_no

                            #            line_run.items.append(run_item)

                            #        '''

                            run_items = find_items(scene, uids)

                            for run_item in run_items:

                                run_item._owner = line_no

                                line_run.items.append(run_item)

                            line_run.owner = line_no

                            line_no.runs.append(line_run)

                        app_doc_data.tracerLineNos.append(line_no)

                    value = value + 1

                    self.show_progress.emit(value)

                # for inst attribute

                for trimLineNo in root.iter('INST_LINE_NO'):

                    line_no = QEngineeringInstLineNoTextItem()

                    line_no.uid = uuid.UUID(trimLineNo.find('UID').text)

                    if symbol and line:

                        runs_node = trimLineNo.findall('RUN')

                        if runs_node is None: continue

                        for run in runs_node:

                            line_run = QEngineeringRunItem()

                            uids = []

                            for child in run:

                                uidElement = child.find('UID')

                                if uidElement is not None:

                                    uid = uidElement.text

                                    uids.append(uid)

                            run_items = find_items(scene, uids)

                            for run_item in run_items:

                                line_run.items.append(run_item)

                            line_run.owner = line_no

                            line_no.runs.append(line_run)

                        app_doc_data._connected_items_lists = line_no

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

            if package:

                if root.find('VENDORS') is not None:

                    for vendor in root.find('VENDORS').iter('VENDOR'):

                        item = QEngineeringVendorItem.fromXml(vendor)

                        scene.addItem(item)

            # connect flow item to line

            for line in lines:

                line.update_arrow()

                #app_doc_data.lines.append(line)

            # for flowMark in [item for item in symbols if type(item) is QEngineeringFlowMarkItem]:

            #    for line in lines:

            #        if flowMark.owner is line:

            #            line._flowMark.append(flowMark)

            #            flowMark.setParentItem(line)

            # up to here

            """

            group_box = QGroupBox("Contact Details")

            number_label = QLabel("Telephone number");

            number_edit = QTextEdit('hello\nthis is ....')

            layout = QFormLayout()

            layout.addRow(number_label, number_edit)

            group_box.setLayout(layout)

            proxy = QGraphicsProxyWidget()

            proxy.setWidget(group_box)

            scene.addItem(proxy)  # (group_box, QGraphicsItem.ItemIgnoresTransformations)

            """

        except Exception as ex:

            from AppDocData import MessageType

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

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

            self.display_message.emit(MessageType.Error, message)

        finally:

            scene.blockSignals(False)

        return value

    def load_data_from_database(self, drawing, scene, symbol, text, line, unknown, package) -> int:

        """load drawing data from database"""

        from App import App

        def find_item(scene, uid):

            items = [item for item in scene.items() if hasattr(item, 'uid') and str(item.uid) == str(uid)]

            return items[0] if items else None

        def find_items(scene, uids):

            uids = [str(uid) for uid in uids]

            items = [(item, uids.index(str(item.uid))) for item in scene.items() if hasattr(item, 'uid') and str(item.uid) in uids]

            items = [item[0] for item in sorted(items, key= lambda param:param[1])]

            return items

        value = 0

        app_doc_data = AppDocData.instance()

        try:

            symbols = []

            lines = []

            components = app_doc_data.get_components(drawing.UID)

            maxValue = len(components) * 2

            self.set_maximum.emit(maxValue) if maxValue > 0 else None

            if symbol:

                """ parsing all symbols """

                for symbol in [component for component in components if int(component['SymbolType_UID']) != -1]:

                    item = SymbolSvgItem.from_database(symbol)

                    if item is not None:

                        symbols.append(item)

                        #app_doc_data.symbols.append(item)

                        item.addSvgItemToScene(scene)

                    else:

                        pt = [float(symbol['X']), float(symbol['Y'])]

                        size = [float(symbol['Width']), float(symbol['Height'])]

                        angle = float(symbol['Rotation'])

                        item = QGraphicsBoundingBoxItem(pt[0], pt[1], size[0], size[1])

                        item.isSymbol = True

                        item.angle = angle

                        item.setPen(QPen(Qt.red, 5, Qt.SolidLine))

                        scene.addItem(item)

                    value = value + 1

                    self.show_progress.emit(value + 1)

                QApplication.processEvents()

            if text:

                # parse texts

                for text in [component for component in components if

                             component['Name'] == 'Text' and component['SymbolType_UID'] == -1]:

                    item = QEngineeringTextItem.from_database(text)

                    if item is not None:

                        item.uid = text['UID']

                        item.attribute = text['Value']

                        name = text['Name']

                        item.addTextItemToScene(scene)

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

                # note

                for note in [component for component in components if

                             component['Name'] == 'Note' and component['SymbolType_UID'] == -1]:

                    item = QEngineeringTextItem.from_database(note)

                    if item is not None:

                        item.uid = note['UID']

                        attributeValue = note['Value']

                        name = note['Name']

                        item.addTextItemToScene(scene)

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

            if line:

                for line in [component for component in components if

                             component['Name'] == 'Line' and component['SymbolType_UID'] == -1]:

                    item = QEngineeringLineItem.from_database(line)

                    if item:

                        scene.addItem(item)

                        lines.append(item)

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

            if unknown:

                for unknown in [component for component in components if

                                component['Name'] == 'Unknown' and component['SymbolType_UID'] == -1]:

                    item = QEngineeringUnknownItem.from_database(unknown)

                    if item is not None:

                        scene.addItem(item)

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

            if text:

                for component in [component for component in components if

                                  component['Name'] == 'Line NO' and component['SymbolType_UID'] == -1]:

                    line_no = QEngineeringLineNoTextItem.from_database(component)

                    if type(line_no) is QEngineeringLineNoTextItem:

                        line_no.addTextItemToScene(scene)

                        if symbol and line:

                            runs = app_doc_data.get_pipe_runs(str(line_no.uid))

                            if not runs: continue

                            for run in runs:

                                line_run = QEngineeringRunItem()

                                run_items = app_doc_data.get_pipe_run_items(run['UID'])

                                uids = [record['Components_UID'] for record in run_items]

                                #for record in run_items:

                                #    uid = record['Components_UID']

                                #    uids.append(uid)

                                #    '''

                                #    run_item = find_item(scene, uid)

                                #    if run_item is not None:

                                #        run_item._owner = line_no

                                #        line_run.items.append(run_item)

                                #    '''

                                run_items = find_items(scene, uids)

                                for run_item in run_items:

                                    run_item._owner = line_no

                                    line_run.items.append(run_item)

                                line_run.owner = line_no

                                line_no.runs.append(line_run)

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

                for component in [component for component in components if

                                  component['Name'] == 'Trim Line NO' and component['SymbolType_UID'] == -1]:

                    line_no = QEngineeringTrimLineNoTextItem()

                    line_no.uid = uuid.UUID(component['UID'])

                    if symbol and line:

                        runs = app_doc_data.get_pipe_runs(str(line_no.uid))

                        if not runs: continue

                        for run in runs:

                            line_run = QEngineeringRunItem()

                            run_items = app_doc_data.get_pipe_run_items(run['UID'])

                            uids = [record['Components_UID'] for record in run_items]

                            #for record in run_items:

                            #    uid = record['Components_UID']

                            #    uids.append(uid)

                            #    '''

                            #    run_item = find_item(scene, uid)

                            #    if run_item is not None:

                            #        run_item.owner = line_no

                            #        line_run.items.append(run_item)

                            #    '''

                            run_items = find_items(scene, uids)

                            for run_item in run_items:

                                run_item._owner = line_no

                                line_run.items.append(run_item)

                            line_run.owner = line_no

                            line_no.runs.append(line_run)

                        app_doc_data.tracerLineNos.append(line_no)

                    value = value + 1

                    self.show_progress.emit(value)

                # for inst attribute

                for component in [component for component in components if

                                  component['Name'] == 'Inst Line NO' and component['SymbolType_UID'] == -1]:

                    line_no = QEngineeringInstLineNoTextItem()

                    line_no.uid = uuid.UUID(component['UID'])

                    if symbol and line:

                        runs = app_doc_data.get_pipe_runs(str(line_no.uid))

                        if not runs: continue

                        for run in runs:

                            line_run = QEngineeringRunItem()

                            run_items = app_doc_data.get_pipe_run_items(run['UID'])

                            uids = [record['Components_UID'] for record in run_items]

                            #for record in run_items:

                            #    uid = record['Components_UID']

                            #    uids.append(uid)

                            run_items = find_items(scene, uids)

                            for run_item in run_items:

                                line_run.items.append(run_item)

                            line_run.owner = line_no

                            line_no.runs.append(line_run)

                        app_doc_data._connected_items_lists = line_no

                    value = value + 1

                    self.show_progress.emit(value)

                QApplication.processEvents()

            if package:

                for component in [component for component in components if

                                component['Name'] == 'VendorPackage' and component['SymbolType_UID'] == -1]:

                    item = QEngineeringVendorItem.from_database(component)

                    if item is not None:

                        scene.addItem(item)

            # connect flow item to line

            for line in lines:

                line.update_arrow()

                #app_doc_data.lines.append(line)

            # for flowMark in [item for item in symbols if type(item) is QEngineeringFlowMarkItem]:

            #    for line in lines:

            #        if flowMark.owner is line:

            #            line._flowMark.append(flowMark)

            #            flowMark.setParentItem(line)

            # up to here

        except Exception as ex:

            from AppDocData import MessageType

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

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

            self.display_message.emit(MessageType.Error, message)

        finally:

            pass

            # scene.blockSignals(False)

        return value