"""
Tests für den Legendenrand weißer Basemap-Flächen (Basis #92).

Weiße Flächen ohne Umrandung (z. B. „Platz“) verschwinden auf dem weißen Legendenhintergrund.
Das Legendensymbol bekommt dann einen dünnen grauen Rand; die Karte bleibt unverändert.
Das Aussehen in der Legende ist im QGIS-Test geprüft.
"""
import unittest
from unittest.mock import patch

from sn_basis.modules import basemap_legende_layout as bll
from sn_basis.modules.basemap_legende_layout import braucht_legendenrand, ergaenze_legendenrand

WEISS = (255, 255, 255, 255)
GRUEN = (200, 230, 160, 255)
GRAU = (120, 120, 120, 255)


class TestBrauchtLegendenrand(unittest.TestCase):

    def test_weisse_flaeche_ohne_rand(self):
        """Prüft, dass eine weiße Fläche ohne Umrandung einen Legendenrand braucht."""
        self.assertTrue(braucht_legendenrand([{"art": "fuellung", "farbe": WEISS, "rand": None}]))

    def test_farbige_flaeche_oder_flaeche_mit_kontur(self):
        """Prüft, dass farbige Flächen und weiße Flächen mit dunkler Kontur oder eigener Konturlinie keinen Rand bekommen."""
        self.assertFalse(braucht_legendenrand([{"art": "fuellung", "farbe": GRUEN, "rand": None}]))
        self.assertFalse(braucht_legendenrand([{"art": "fuellung", "farbe": WEISS, "rand": GRAU}]))
        self.assertFalse(braucht_legendenrand([{"art": "fuellung", "farbe": WEISS, "rand": None},
                                               {"art": "linie", "farbe": GRAU}]))

    def test_heller_rand_und_fast_weiss_zaehlen_als_unsichtbar(self):
        """Prüft, dass fast weiße Füllungen und helle oder durchsichtige Ränder als unsichtbar gelten."""
        self.assertTrue(braucht_legendenrand([{"art": "fuellung", "farbe": (250, 248, 245, 255),
                                               "rand": (255, 255, 255, 255)}]))
        self.assertTrue(braucht_legendenrand([{"art": "fuellung", "farbe": WEISS, "rand": (0, 0, 0, 0)}]))

    def test_andere_ebenen_und_leeres_symbol(self):
        """Prüft, dass Symbole mit anderen Ebenen (Muster, Punkte) und leere Symbole keinen Rand bekommen."""
        self.assertFalse(braucht_legendenrand([{"art": "sonst", "farbe": WEISS}]))
        self.assertFalse(braucht_legendenrand([]))


class _Farbe:
    def __init__(self, r, g, b, a=255): self.w = (r, g, b, a)
    def red(self): return self.w[0]
    def green(self): return self.w[1]
    def blue(self): return self.w[2]
    def alpha(self): return self.w[3]


class _Fuellung:
    def __init__(self, farbe, rand_stil=0, rand=(0, 0, 0, 255)):
        self._farbe, self._rand_stil, self._rand = _Farbe(*farbe), rand_stil, _Farbe(*rand)

    def layerType(self): return "SimpleFill"
    def color(self): return self._farbe
    def strokeStyle(self): return self._rand_stil
    def strokeColor(self): return self._rand


class _Symbol:
    def __init__(self, typ, *ebenen):
        self._typ, self.ebenen = typ, list(ebenen)

    def type(self): return self._typ
    def symbolLayers(self): return list(self.ebenen)
    def appendSymbolLayer(self, ebene): self.ebenen.append(ebene)


class _Linienebene:
    erzeugt = []

    @classmethod
    def create(cls, eigenschaften):
        cls.erzeugt.append(eigenschaften)
        return ("Rand", eigenschaften)


@patch.object(bll, "QgsSimpleLineSymbolLayer", _Linienebene)
class TestErgaenzeLegendenrand(unittest.TestCase):

    def test_weisse_flaeche_bekommt_grauen_rand(self):
        """Prüft, dass eine weiße Fläche ohne Kontur eine graue Randlinie als oberste Ebene bekommt."""
        symbol = _Symbol(2, _Fuellung(WEISS))
        self.assertTrue(ergaenze_legendenrand(symbol))
        self.assertEqual(len(symbol.ebenen), 2)
        eigenschaften = symbol.ebenen[-1][1]
        self.assertEqual(eigenschaften["line_width"], str(bll.LEGENDENRAND_BREITE_MM))
        self.assertEqual(eigenschaften["line_color"], bll.LEGENDENRAND_FARBE)

    def test_farbige_flaeche_und_linien_bleiben_unveraendert(self):
        """Prüft, dass farbige Flächen, Flächen mit Kontur und Liniensymbole keinen Rand bekommen."""
        for symbol in (_Symbol(2, _Fuellung(GRUEN)), _Symbol(2, _Fuellung(WEISS, rand_stil=1, rand=GRAU)),
                       _Symbol(1, _Fuellung(WEISS))):
            anzahl = len(symbol.ebenen)
            self.assertFalse(ergaenze_legendenrand(symbol))
            self.assertEqual(len(symbol.ebenen), anzahl)


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