from PySide6.QtWidgets import QDialog, QTableWidgetItem, QMessageBox
from PySide6.QtCore import Qt

from ui.TreeNodeEditDialog_ui import Ui_TreeNodeEditDialog


class TreeNodeEditDialog(QDialog):
    """Dialog zur Bearbeitung von TreeNode-Objekten."""

    def __init__(self, parent=None, node=None, parent_params=None):
        """
        Initialisiert den Dialog.
        
        Args:
            parent: Übergeordnetes Widget
            node: TreeNode-Objekt zum Bearbeiten
            parent_params: Dictionary mit Eltern-Parametern (nur anzeigen)
        """
        super().__init__(parent)

        # UI einrichten
        self.ui = Ui_TreeNodeEditDialog()
        self.ui.setupUi(self)

        # Node-Objekt speichern
        self.node = node
        self.parent_params = parent_params or {}

        # Signale verbinden
        self.ui.addParamButton.clicked.connect(self.add_parameter)
        self.ui.removeParamButton.clicked.connect(self.remove_parameter)

        # Tabellen konfigurieren
        self._setup_tables()

        # Daten laden
        if self.node:
            self._load_data()

    def _setup_tables(self):
        """Konfiguriert die Tabellen."""
        # XSLT Parameter Tabelle
        self.ui.xsltParamsTable.setColumnWidth(0, 200)
        self.ui.xsltParamsTable.setColumnWidth(1, 300)
        self.ui.xsltParamsTable.horizontalHeader().setStretchLastSection(True)

        # Eltern-Parameter Tabelle
        self.ui.parentParamsTable.setColumnWidth(0, 200)
        self.ui.parentParamsTable.setColumnWidth(1, 300)
        self.ui.parentParamsTable.horizontalHeader().setStretchLastSection(True)

    def _load_data(self):
        """Lädt die Daten des TreeNode in den Dialog."""
        if not self.node:
            return

        # Bezeichnung setzen
        self.ui.bezEdit.setText(str(self.node.bez) if self.node.bez else "")

        # XSLT Parameter laden
        self._load_xslt_params()

        # Eltern-Parameter laden
        self._load_parent_params()

    def _load_xslt_params(self):
        """Lädt die XSLT Parameter in die Tabelle."""
        if not self.node or not self.node.xslt_params:
            return

        params = self.node.xslt_params
        self.ui.xsltParamsTable.setRowCount(len(params))

        for row, (key, value) in enumerate(params.items()):
            # Parameter-Name
            key_item = QTableWidgetItem(str(key))
            self.ui.xsltParamsTable.setItem(row, 0, key_item)

            # Parameter-Wert
            value_item = QTableWidgetItem(str(value))
            self.ui.xsltParamsTable.setItem(row, 1, value_item)

    def _load_parent_params(self):
        """Lädt die Eltern-Parameter in die Tabelle (nur anzeigen)."""
        if not self.parent_params:
            return

        self.ui.parentParamsTable.setRowCount(len(self.parent_params))

        for row, (key, value) in enumerate(self.parent_params.items()):
            # Parameter-Name
            key_item = QTableWidgetItem(str(key))
            key_item.setFlags(key_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
            self.ui.parentParamsTable.setItem(row, 0, key_item)

            # Parameter-Wert
            value_item = QTableWidgetItem(str(value))
            value_item.setFlags(value_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
            self.ui.parentParamsTable.setItem(row, 1, value_item)

    def add_parameter(self):
        """Fügt einen neuen Parameter hinzu."""
        row_count = self.ui.xsltParamsTable.rowCount()
        self.ui.xsltParamsTable.insertRow(row_count)

        # Leere Items hinzufügen
        key_item = QTableWidgetItem("")
        value_item = QTableWidgetItem("")

        self.ui.xsltParamsTable.setItem(row_count, 0, key_item)
        self.ui.xsltParamsTable.setItem(row_count, 1, value_item)

        # Fokus auf den neuen Parameter setzen
        self.ui.xsltParamsTable.setCurrentCell(row_count, 0)

    def remove_parameter(self):
        """Entfernt den ausgewählten Parameter."""
        current_row = self.ui.xsltParamsTable.currentRow()
        if current_row >= 0:
            self.ui.xsltParamsTable.removeRow(current_row)

    def get_data(self):
        """
        Gibt die bearbeiteten Daten zurück.

        Returns:
            dict: Dictionary mit den bearbeiteten Daten oder None bei Fehler
        """
        # Bezeichnung prüfen
        bez = self.ui.bezEdit.text().strip()
        if not bez:
            QMessageBox.warning(self, "Warnung", "Bitte geben Sie eine Bezeichnung ein.")
            return None

        # XSLT Parameter sammeln
        xslt_params = {}
        for row in range(self.ui.xsltParamsTable.rowCount()):
            key_item = self.ui.xsltParamsTable.item(row, 0)
            value_item = self.ui.xsltParamsTable.item(row, 1)

            if key_item and value_item:
                key = key_item.text().strip()
                value = value_item.text().strip()

                if key:  # Nur Parameter mit nicht-leerem Schlüssel hinzufügen
                    xslt_params[key] = value

        # CheckBox für Force-Transformation prüfen
        force_transform = self.ui.alle_xml_transformieren.isChecked()

        return {
            "bez": bez,
            "xslt_params": xslt_params,
            "force_transform": force_transform
        }

    def accept(self):
        """Überschreibt accept() um Datenvalidierung durchzuführen."""
        data = self.get_data()
        if data is not None:
            super().accept()