# sn_basis/test/test_wrapper.py

import unittest
import os
import tempfile

# Wrapper importieren
import sn_basis.functions.syswrapper as syswrapper
import sn_basis.functions.qgisqt_wrapper as qgisqt


# ---------------------------------------------------------
# Mock-Layer für qgisqt_wrapper
# ---------------------------------------------------------
class MockLayer:
    def __init__(
        self,
        exists=True,
        visible=True,
        layer_type="vector",
        geometry_type="Polygon",
        feature_count=10,
        crs="EPSG:25833",
        fields=None,
        source="/tmp/test.shp",
        editable=True,
    ):
        self.exists = exists
        self.visible = visible
        self.layer_type = layer_type
        self.geometry_type = geometry_type
        self.feature_count = feature_count
        self.crs = crs
        self.fields = fields or []
        self.source = source
        self.editable = editable


# ---------------------------------------------------------
# Monkeypatching für qgisqt_wrapper
# ---------------------------------------------------------
def mock_layer_exists(layer):
    return layer is not None and layer.exists


def mock_is_layer_visible(layer):
    return layer.visible


def mock_get_layer_type(layer):
    return layer.layer_type


def mock_get_layer_geometry_type(layer):
    return layer.geometry_type


def mock_get_layer_feature_count(layer):
    return layer.feature_count


def mock_get_layer_crs(layer):
    return layer.crs


def mock_get_layer_fields(layer):
    return layer.fields


def mock_get_layer_source(layer):
    return layer.source


def mock_is_layer_editable(layer):
    return layer.editable


# ---------------------------------------------------------
# Testklasse
# ---------------------------------------------------------
class TestWrapper(unittest.TestCase):

    def setUp(self):
        # qgisqt_wrapper monkeypatchen
        qgisqt.layer_exists = mock_layer_exists
        qgisqt.is_layer_visible = mock_is_layer_visible
        qgisqt.get_layer_type = mock_get_layer_type
        qgisqt.get_layer_geometry_type = mock_get_layer_geometry_type
        qgisqt.get_layer_feature_count = mock_get_layer_feature_count
        qgisqt.get_layer_crs = mock_get_layer_crs
        qgisqt.get_layer_fields = mock_get_layer_fields
        qgisqt.get_layer_source = mock_get_layer_source
        qgisqt.is_layer_editable = mock_is_layer_editable

    # -----------------------------------------------------
    # syswrapper Tests
    # -----------------------------------------------------

    def test_syswrapper_file_exists(self):
        with tempfile.NamedTemporaryFile(delete=True) as tmp:
            self.assertTrue(syswrapper.file_exists(tmp.name))
        self.assertFalse(syswrapper.file_exists("/path/does/not/exist"))

    def test_syswrapper_is_file(self):
        with tempfile.NamedTemporaryFile(delete=True) as tmp:
            self.assertTrue(syswrapper.is_file(tmp.name))
        self.assertFalse(syswrapper.is_file("/path/does/not/exist"))

    def test_syswrapper_join_path(self):
        result = syswrapper.join_path("/tmp", "test.txt")
        self.assertEqual(result, "/tmp/test.txt")

    # -----------------------------------------------------
    # qgisqt_wrapper Tests (Mock-Modus)
    # -----------------------------------------------------

    def test_qgisqt_layer_exists(self):
        layer = MockLayer(exists=True)
        self.assertTrue(qgisqt.layer_exists(layer))

        layer = MockLayer(exists=False)
        self.assertFalse(qgisqt.layer_exists(layer))

    def test_qgisqt_layer_visible(self):
        layer = MockLayer(visible=True)
        self.assertTrue(qgisqt.is_layer_visible(layer))

        layer = MockLayer(visible=False)
        self.assertFalse(qgisqt.is_layer_visible(layer))

    def test_qgisqt_layer_type(self):
        layer = MockLayer(layer_type="vector")
        self.assertEqual(qgisqt.get_layer_type(layer), "vector")

    def test_qgisqt_geometry_type(self):
        layer = MockLayer(geometry_type="Polygon")
        self.assertEqual(qgisqt.get_layer_geometry_type(layer), "Polygon")

    def test_qgisqt_feature_count(self):
        layer = MockLayer(feature_count=12)
        self.assertEqual(qgisqt.get_layer_feature_count(layer), 12)

    def test_qgisqt_crs(self):
        layer = MockLayer(crs="EPSG:4326")
        self.assertEqual(qgisqt.get_layer_crs(layer), "EPSG:4326")

    def test_qgisqt_fields(self):
        layer = MockLayer(fields=["id", "name"])
        self.assertEqual(qgisqt.get_layer_fields(layer), ["id", "name"])

    def test_qgisqt_source(self):
        layer = MockLayer(source="/tmp/test.shp")
        self.assertEqual(qgisqt.get_layer_source(layer), "/tmp/test.shp")

    def test_qgisqt_editable(self):
        layer = MockLayer(editable=True)
        self.assertTrue(qgisqt.is_layer_editable(layer))

        layer = MockLayer(editable=False)
        self.assertFalse(qgisqt.is_layer_editable(layer))


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