"""Tests für den Tab „Eigentümer“ – Flurstückssuche und Eigentümersuche (#56).

Alle Namen und Anschriften sind erfunden.
"""

import sys
import types
import unittest
from unittest.mock import MagicMock, patch

if "qgis" not in sys.modules:
    qgis_mod = types.ModuleType("qgis")
    qgis_utils = types.ModuleType("qgis.utils")
    qgis_utils.iface = types.SimpleNamespace()
    qgis_utils.plugins = {}
    qgis_mod.utils = qgis_utils
    sys.modules["qgis"] = qgis_mod
    sys.modules["qgis.utils"] = qgis_utils

from sn_verfahrensgebiet.ui.tabs import eigentuemer_tab as et
from sn_verfahrensgebiet.ui.tabs.eigentuemer_tab import EigentuemerTab
from sn_verfahrensgebiet.functions.flurstueck_suche import (
    FlurstueckSucheFehler,
    KeinFlurstueckslayer,
    SuchErgebnis,
)
from sn_verfahrensgebiet.functions.eigentuemer_suche import Eigentuemer, EigentuemerSucheFehler
from sn_verfahrensgebiet.ui import eigentuemer_treffer as treffer_modul
from sn_verfahrensgebiet.ui.eigentuemer_treffer import EigentuemerTrefferFenster, trefferzeile


def _tab(gemarkung="0268", flurstueck="562"):
    tab = EigentuemerTab.__new__(EigentuemerTab)
    tab.gemarkung_edit = types.SimpleNamespace(text=lambda: gemarkung)
    tab.flurstueck_edit = types.SimpleNamespace(text=lambda: flurstueck)
    return tab


@patch.object(et, "success")
@patch.object(et, "info")
@patch.object(et, "warning")
@patch.object(et, "show_info_dialog")
class TestFlurstueckSuchen(unittest.TestCase):

    def test_ohne_flurstueckslayer_erscheint_hinweisdialog(self, dialog, warnung, hinweis, erfolg):
        """Prüft, dass ohne Layer „Flurstücke“ ein Dialog zum Laden von Verfahrensgebiet und Flurstücken erscheint."""
        with patch.object(et, "flurstueck_suchen", side_effect=KeinFlurstueckslayer()):
            _tab()._on_flurstueck_suchen()
        dialog.assert_called_once()
        self.assertIn("Flurstücke aus ALKIS laden", dialog.call_args[0][1])
        warnung.assert_not_called()
        erfolg.assert_not_called()

    def test_eingabefehler_als_warnung(self, dialog, warnung, hinweis, erfolg):
        """Prüft, dass eine ungültige Eingabe als Warnung in der Meldungsleiste erscheint, nicht als Dialog."""
        with patch.object(et, "flurstueck_suchen", side_effect=FlurstueckSucheFehler("falsch")):
            _tab()._on_flurstueck_suchen()
        warnung.assert_called_once_with("Flurstückssuche", "falsch")
        dialog.assert_not_called()

    def test_kein_treffer(self, dialog, warnung, hinweis, erfolg):
        """Prüft, dass ohne Treffer ein Hinweis erscheint und keine Auswahl gesetzt wird."""
        layer = MagicMock()
        with patch.object(et, "flurstueck_suchen", return_value=SuchErgebnis(layer, [])):
            _tab(flurstueck="999")._on_flurstueck_suchen()
        hinweis.assert_called_once()
        self.assertIn("999", hinweis.call_args[0][1])
        layer.selectByIds.assert_not_called()

    def test_treffer_werden_ausgewaehlt_und_angezoomt(self, dialog, warnung, hinweis, erfolg):
        """Prüft, dass Treffer im Flurstückslayer ausgewählt, angezoomt und gemeldet werden."""
        layer = MagicMock()
        layer.name.return_value = "Flurstücke"
        canvas = MagicMock()
        with patch.object(et, "flurstueck_suchen", return_value=SuchErgebnis(layer, [1, 2])) as suche, \
                patch.object(et, "iface", types.SimpleNamespace(mapCanvas=lambda: canvas)):
            _tab(gemarkung=" Beispielhausen ", flurstueck=" 562 ")._on_flurstueck_suchen()
        suche.assert_called_once_with("Beispielhausen", "562")
        layer.selectByIds.assert_called_once_with([1, 2])
        canvas.zoomToSelected.assert_called_once_with(layer)
        canvas.flashFeatureIds.assert_called_once_with(layer, [1, 2])
        erfolg.assert_called_once()
        self.assertIn("2 Flurstücke", erfolg.call_args[0][1])

    def test_ohne_kartenansicht_bleibt_auswahl(self, dialog, warnung, hinweis, erfolg):
        """Prüft, dass die Auswahl auch ohne Kartenansicht gesetzt und gemeldet wird."""
        layer = MagicMock()
        with patch.object(et, "flurstueck_suchen", return_value=SuchErgebnis(layer, [7])), \
                patch.object(et, "iface", types.SimpleNamespace()):
            _tab()._on_flurstueck_suchen()
        layer.selectByIds.assert_called_once_with([7])
        self.assertIn("1 Flurstück", erfolg.call_args[0][1])


def _eig_tab(nachname="Beispiel", vorname="", layer_id="csv1"):
    tab = EigentuemerTab.__new__(EigentuemerTab)
    tab.nachname_edit = types.SimpleNamespace(text=lambda: nachname)
    tab.vorname_edit = types.SimpleNamespace(text=lambda: vorname)
    tab.eigentuemer_layer_combo = MagicMock()
    tab.eigentuemer_layer_combo.currentData.return_value = layer_id
    tab._trefferfenster = None
    return tab


_ANNA = Eigentuemer(vorname="Anna", nachname="Beispiel", strasse="Hauptstraße 1", plz="01234",
                    wohnort="Musterstadt", emails=("anna@example.org",), verstorben=True,
                    rechtsperson=("0",))


@patch.object(et, "info")
@patch.object(et, "warning")
class TestEigentuemerSuchen(unittest.TestCase):

    def test_ohne_eigentuemerdatei_warnung(self, warnung, hinweis):
        """Prüft, dass ohne gewählte Eigentümerdatei die Liste aufgefrischt und dann auf das Laden der CSV hingewiesen wird."""
        tab = _eig_tab(layer_id=None)
        with patch.object(et, "hole_layer", return_value=None),                 patch.object(et, "suche_eigentuemer") as suche:
            tab._on_eigentuemer_suchen()
        tab.eigentuemer_layer_combo.aktualisieren.assert_called_once()
        warnung.assert_called_once()
        self.assertIn("CSV", warnung.call_args[0][1])
        suche.assert_not_called()

    def test_suchfehler_als_warnung(self, warnung, hinweis):
        """Prüft, dass ein Fehler der Suche (z. B. leere Eingabe) als Warnung erscheint."""
        with patch.object(et, "hole_layer", return_value=object()),                 patch.object(et, "suche_eigentuemer", side_effect=EigentuemerSucheFehler("Bitte eingeben")):
            _eig_tab()._on_eigentuemer_suchen()
        warnung.assert_called_once_with("Eigentümersuche", "Bitte eingeben")

    def test_kein_treffer_ohne_namen_in_meldung(self, warnung, hinweis):
        """Prüft, dass ohne Treffer ein Hinweis erscheint, der den gesuchten Namen nicht wiederholt (Datenschutz)."""
        with patch.object(et, "hole_layer", return_value=object()),                 patch.object(et, "suche_eigentuemer", return_value=[]),                 patch.object(et, "EigentuemerTrefferFenster") as fenster:
            _eig_tab(nachname="Beispiel")._on_eigentuemer_suchen()
        hinweis.assert_called_once()
        self.assertNotIn("Beispiel", hinweis.call_args[0][1])
        fenster.assert_not_called()

    def test_treffer_oeffnen_trefferliste_und_ersetzen_die_alte(self, warnung, hinweis):
        """Prüft, dass Treffer in einer neuen Trefferliste erscheinen, eine offene alte Liste geschlossen wird und die Eingaben an die Suche gehen."""
        layer = object()
        tab = _eig_tab(nachname="Beisp", vorname="An")
        altes_fenster = MagicMock()
        tab._trefferfenster = altes_fenster
        with patch.object(et, "hole_layer", return_value=layer),                 patch.object(et, "suche_eigentuemer", return_value=[_ANNA]) as suche,                 patch.object(et, "EigentuemerTrefferFenster") as fenster:
            tab._on_eigentuemer_suchen()
        suche.assert_called_once_with(layer, "Beisp", "An")
        altes_fenster.close.assert_called_once()
        fenster.assert_called_once_with([_ANNA], tab)
        fenster.return_value.show.assert_called_once()
        self.assertIs(tab._trefferfenster, fenster.return_value)


class TestTrefferliste(unittest.TestCase):

    def test_trefferzeile_mit_hinweis(self):
        """Prüft, dass die Trefferliste Name, Anschrift, E-Mail, den Rohwert von PER_RECHTSPERSON und das Kennzeichen „verstorben“ zeigt."""
        self.assertEqual(
            trefferzeile(_ANNA),
            ("Beispiel, Anna", "Hauptstraße 1, 01234 Musterstadt", "anna@example.org", "0", "verstorben"),
        )

    def test_ausgewaehlte_eigentuemer(self):
        """Prüft, dass das Trefferfenster die in der Tabelle gewählten Einträge zurückgibt."""
        bernd = Eigentuemer(vorname="Bernd", nachname="Muster")
        fenster = EigentuemerTrefferFenster.__new__(EigentuemerTrefferFenster)
        fenster.treffer = [_ANNA, bernd]
        fenster.tabelle = object()
        with patch.object(treffer_modul, "ausgewaehlte_indizes", return_value=[1]) as indizes:
            self.assertEqual(fenster.ausgewaehlte_eigentuemer(), [bernd])
        indizes.assert_called_once_with(fenster.tabelle)


class TestDockWidgetTabs(unittest.TestCase):

    def test_tab_ist_im_dockwidget_eingetragen(self):
        """Prüft, dass der Tab „Eigentümer“ im DockWidget direkt nach dem Bearbeitungs-Tab steht."""
        from sn_verfahrensgebiet.ui.dockwidget import DockWidget
        from sn_verfahrensgebiet.ui.tabs.working_tab import WorkingTab

        self.assertEqual(DockWidget.tabs[:2], [WorkingTab, EigentuemerTab])
        self.assertEqual(EigentuemerTab.tab_title, "Eigentümer")


if __name__ == "__main__":
    unittest.main()