import unittest
from unittest.mock import patch
from typing import Any, cast

from sn_plan41.ui.tab_a_logic import TabALogic


class _DummyPruefmanager:
    def __init__(self) -> None:
        self.hinweise: list[tuple[str, str]] = []

    def verarbeite(self, ergebnis):
        return ergebnis

    def zeige_hinweis(self, titel: str, meldung: str) -> None:
        self.hinweise.append((titel, meldung))


class _DummyDateiErgebnis:
    def __init__(self, ok: bool = True, kontext: str = "C:/tmp/v_db.gpkg") -> None:
        self.ok = ok
        self.kontext = kontext


class _DummyProgress:
    def __init__(self) -> None:
        self.closed = False

    def set_total(self, _value: int) -> None:
        pass

    def set_value(self, _value: int) -> None:
        pass

    def set_label(self, _value: str) -> None:
        pass

    def close(self) -> None:
        self.closed = True


class _DummyProject:
    def mapLayer(self, _layer_id: str):
        return None


class _DummyGrabber:
    pass


class TestTabAPreconditions(unittest.TestCase):

    def _make_logic(self) -> tuple[TabALogic, _DummyPruefmanager]:
        pruefmanager = _DummyPruefmanager()
        logic = TabALogic(
            pruefmanager=cast(Any, pruefmanager),
            link_pruefer=cast(Any, object()),
            stil_pruefer=cast(Any, object()),
        )
        return logic, pruefmanager

    def test_get_verfahrensgebiet_layer_shows_hint_when_layer_id_missing(self):
        logic, pruefmanager = self._make_logic()

        with patch.object(logic, "load_verfahrensgebiet_layer_id", return_value=None):
            layer = logic._get_verfahrensgebiet_layer()

        self.assertIsNone(layer)
        self.assertEqual(len(pruefmanager.hinweise), 1)
        self.assertIn("Verfahrensgebiet", pruefmanager.hinweise[0][0])

    @patch("sn_plan41.ui.tab_a_logic.QgsProject.instance", return_value=_DummyProject())
    def test_get_verfahrensgebiet_layer_shows_hint_when_layer_not_in_project(self, _mock_project_instance):
        logic, pruefmanager = self._make_logic()

        with patch.object(logic, "load_verfahrensgebiet_layer_id", return_value="layer_404"):
            layer = logic._get_verfahrensgebiet_layer()

        self.assertIsNone(layer)
        self.assertEqual(len(pruefmanager.hinweise), 1)
        self.assertIn("Verfahrensgebiet", pruefmanager.hinweise[0][0])

    @patch("sn_plan41.ui.tab_a_logic.Dateipruefer")
    def test_pipeline_aborts_and_shows_hint_when_verfahrensgebiet_missing(
        self,
        mock_dateipruefer,
    ):
        logic, pruefmanager = self._make_logic()
        logic.data_grabber = cast(Any, _DummyGrabber())

        mock_dateipruefer.return_value.pruefe.return_value = _DummyDateiErgebnis(ok=True, kontext="C:/tmp/v_db.gpkg")

        progress = _DummyProgress()

        with patch("sn_plan41.ui.tab_a_logic.create_progress_dialog", return_value=progress):
            with patch.object(logic, "_resolve_linkliste", return_value="C:/tmp/linkliste.xlsx"):
                with patch.object(logic, "load_verfahrensgebiet_layer_id", return_value=None):
                    result = logic._on_run_pipeline(
                        source="C:/tmp/v_db.gpkg",
                        linkliste=None,
                        raumfilter="Verfahrensgebiet",
                    )

        self.assertIsNone(result)
        self.assertEqual(len(pruefmanager.hinweise), 1)
        self.assertIn("Verfahrensgebiet", pruefmanager.hinweise[0][0])
        self.assertTrue(progress.closed)


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