from sn_basis.functions.qt_wrapper import QWidget, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QMessageBox
from sn_basis.functions.qt_wrapper import Qt
from sn_basis.functions import Qgis, QgsProject #QgsMessageLog
from sn_basis.functions.qgisui_wrapper import QgsMapLayerComboBox
from sn_basis.functions.qgiscore_wrapper import QgsMapLayerProxyModel
from sn_basis.functions.verfahrensgebiet_manager import get_verfahrensgebiet_layer_id, set_verfahrensgebiet_layer_id
from qgis.utils import iface

from sn_verfahrensgebiet.functions.verfahrensgebiet_alkis import verfahrensgebiet_alkis, LoadStatus
from sn_basis.functions.message_wrapper import success, info, warning, error
from sn_basis.functions.ly_style_wrapper import apply_style

class WorkingTab(QWidget):
    tab_title = "Bearbeitung"

    def __init__(self, parent=None):
        super().__init__(parent)

        layout = QVBoxLayout()
        layout.setAlignment(Qt.AlignmentFlag.AlignTop)

        # Abschnitt 1: Verfahrensgebiet
        row_verf_header = QHBoxLayout()
        lbl_verf = QLabel("<b>Verfahrensgebiet</b>")
        self.haken_verf = self._haken_label()
        row_verf_header.addWidget(lbl_verf)
        row_verf_header.addWidget(self.haken_verf)
        row_verf_header.addStretch()
        layout.addLayout(row_verf_header)

        row_verf_buttons = QHBoxLayout()
        self.btn_verf_alkis = QPushButton("Aus ALKIS laden")
        self.btn_verf_shape = QPushButton("Aus Shape laden")
        row_verf_buttons.addWidget(self.btn_verf_alkis)
        row_verf_buttons.addWidget(self.btn_verf_shape)
        layout.addLayout(row_verf_buttons)

        # Abschnitt 1b: Verfahrensgebiet-Layer auswählen
        row_layer_label = QHBoxLayout()
        lbl_layer = QLabel("Oder: Verfahrensgebiet-Layer auswählen")
        lbl_layer.setStyleSheet("font-style: italic; color: gray; margin-top: 8px;")
        row_layer_label.addWidget(lbl_layer)
        row_layer_label.addStretch()
        layout.addLayout(row_layer_label)

        self.verf_layer_combo = QgsMapLayerComboBox(self)
        self.verf_layer_combo.setFilters(QgsMapLayerProxyModel.VectorLayer)
        self.verf_layer_combo.setToolTip("Wähle den Verfahrensgebiet-Layer, oder lasse es leer für Automatik")
        self.verf_layer_combo.layerChanged.connect(self._on_verf_layer_changed)
        layout.addWidget(self.verf_layer_combo)

        # Abschnitt 2: Flurstücke (Platzhalter für spätere Implementierung)

        row_flurst_header = QHBoxLayout()
        lbl_flurst = QLabel("<b>Flurstücke</b>")
        self.haken_flurst = self._haken_label()
        row_flurst_header.addWidget(lbl_flurst)
        row_flurst_header.addWidget(self.haken_flurst)
        row_flurst_header.addStretch()
        layout.addLayout(row_flurst_header)

        row_flurst_buttons = QHBoxLayout()
        self.btn_flurst_alkis = QPushButton("Aus ALKIS laden")
        self.btn_flurst_shape = QPushButton("Aus Shape laden")
        row_flurst_buttons.addWidget(self.btn_flurst_alkis)
        row_flurst_buttons.addWidget(self.btn_flurst_shape)
        layout.addLayout(row_flurst_buttons)

        layout.addStretch()
        self.setLayout(layout)

        # Signale verbinden
        self.btn_verf_alkis.clicked.connect(self.handle_verf_alkis)
        # self.btn_verf_shape.clicked.connect(self.handle_verf_shape)
        # self.btn_flurst_alkis.clicked.connect(self.handle_flurst_alkis)
        # self.btn_flurst_shape.clicked.connect(self.handle_flurst_shape)

        # Beim Init: aktuelle Verfahrensgebiet-Layer-ID laden und im Dropdown anzeigen
        self._restore_verf_layer_selection()

    def handle_verf_alkis(self):
        self._set_busy(self.btn_verf_alkis, True)
        try:
            layer, status = verfahrensgebiet_alkis(self)
            if not layer or not layer.isValid():
                set_verfahrensgebiet_layer_id("")
                return

            if status in (LoadStatus.FIRST, LoadStatus.RELOAD):
                # Gemeinsame Logik für erstmaliges und erneutes Laden
                QgsProject.instance().addMapLayer(layer)
                iface.mapCanvas().setExtent(layer.extent())
                #iface.mapCanvas().refresh()

                apply_style(layer, "verfahrensgebiet.qml")
                iface.mapCanvas().refresh()
                self.setze_haken(self.haken_verf, True)

                # Dropdown + Variable explizit synchronisieren.
                self.verf_layer_combo.setLayer(layer)
                self._on_verf_layer_changed(layer)

                # Unterschied nur in der Meldung
                msg = "erstmalig geladen" if status == LoadStatus.FIRST else "neu geladen"
                success("Verfahrensgebiet", f"Layer wurde {msg}.", duration=5)

            elif status == LoadStatus.KEEP:
                self.verf_layer_combo.setLayer(layer)
                self._on_verf_layer_changed(layer)
                info("Verfahrensgebiet", "Vorhandener Layer wurde behalten.", duration=4)

            elif status == LoadStatus.NONE:
                self._on_verf_layer_changed(None)
                warning("Verfahrensgebiet", "Layer konnte nicht geladen werden.", duration=None)

        finally:
            self._set_busy(self.btn_verf_alkis, False)

    def _set_busy(self, button: QPushButton, busy: bool):
        button.setEnabled(not busy)
        if busy:
            button.setText("Lade ...")
        else:
            button.setText("Aus ALKIS laden")

    def _haken_label(self) -> QLabel:
        label = QLabel()
        label.setFixedSize(20, 20)
        label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        label.setText("")  # Start ohne Haken
        return label

    def setze_haken(self, label: QLabel, aktiv: bool):
        """Zeigt oder entfernt den grünen Haken (Unicode), ohne Theme-Icons."""
        if aktiv:
            label.setText("✓")
            label.setStyleSheet("color: #2ea043; font-weight: bold;")
        else:
            label.setText("")
            label.setStyleSheet("")

    def _on_verf_layer_changed(self, layer) -> None:
        """Callback: Nutzer hat einen anderen Layer im Dropdown gewählt."""
        if layer and layer.isValid():
            # Speichere die Layer-ID in der zentralen Variable
            set_verfahrensgebiet_layer_id(layer.id())
        else:
            # Layer is None oder invalid; leere die Variable
            set_verfahrensgebiet_layer_id("")

    def _restore_verf_layer_selection(self) -> None:
        """Beim Tab-Init: Lade die zuletzt gespeicherte Verfahrensgebiet-Layer-ID."""
        layer_id = get_verfahrensgebiet_layer_id()
        if layer_id:
            # Versuche, den Layer im Projekt zu finden
            try:
                project = QgsProject.instance()
                layer = project.mapLayer(layer_id)
                if layer and layer.isValid():
                    self.verf_layer_combo.setLayer(layer)
            except Exception:
                pass