import pytest

from monday_com_orca_backend.utils import custom_types as ct


class TestFrozenDict:
    @pytest.fixture
    def simple_dict(self):
        return {"a": 1, "b": 2}

    @pytest.fixture
    def nested_dict(self):
        return {"a": [1, 2, {"b": 3}], "c": {"d": [4, 5]}}

    def test_basic_usage(self, simple_dict):
        d = ct.FrozenDict(simple_dict)
        assert d["a"] == 1
        assert d["b"] == 2
        assert len(d) == 2
        assert set(d) == {"a", "b"}
        assert "a" in d
        assert "c" not in d
        assert repr(d).startswith("FrozenDict")

    def test_immutable_setitem(self, simple_dict):
        d = ct.FrozenDict(simple_dict)
        with pytest.raises(TypeError):
            d["a"] = 2

    def test_immutable_delitem(self, simple_dict):
        d = ct.FrozenDict(simple_dict)
        with pytest.raises(TypeError):
            del d["a"]

    def test_recursive_freeze(self, nested_dict):
        d = ct.FrozenDict(nested_dict)
        assert isinstance(d["a"], tuple)
        assert isinstance(d["a"][2], ct.FrozenDict)
        assert isinstance(d["c"], ct.FrozenDict)
        assert isinstance(d["c"]["d"], tuple)
        assert d["a"][2]["b"] == 3

    def test_hashable_and_equality(self, simple_dict):
        d1 = ct.FrozenDict(simple_dict)
        d2 = ct.FrozenDict({"b": 2, "a": 1})
        assert hash(d1) == hash(d2)
        assert d1 == d2
        s = {d1, d2}
        assert len(s) == 1

    def test_unhashable_value(self):
        class Unhashable:
            __hash__ = None

        d = ct.FrozenDict({"a": Unhashable()})
        with pytest.raises(TypeError):
            hash(d)

    def test_with_kwargs(self):
        d = ct.FrozenDict(a=1, b=2)
        assert d["a"] == 1
        assert d["b"] == 2

    def test_from_iterable(self):
        d = ct.FrozenDict([("a", 1), ("b", 2)])
        assert d["a"] == 1
        assert d["b"] == 2

    def test_contains(self):
        d = ct.FrozenDict({"x": 10})
        assert "x" in d
        assert "y" not in d

    def test_freeze_dict_and_nested(self, nested_dict):
        frozen = ct._freeze(nested_dict)
        assert isinstance(frozen, ct.FrozenDict)
        assert isinstance(frozen["a"], tuple)
        assert isinstance(frozen["a"][2], ct.FrozenDict)
        assert isinstance(frozen["c"], ct.FrozenDict)
        assert isinstance(frozen["c"]["d"], tuple)

    def test_freeze_list_tuple_set(self):
        obj = [1, 2, {3, 4}, (5, 6)]
        frozen = ct._freeze(obj)
        assert isinstance(frozen, tuple)
        assert isinstance(frozen[2], tuple)
        assert isinstance(frozen[3], tuple)

    def test_freeze_already_frozen(self):
        d = ct.FrozenDict({"a": 1})
        assert ct._freeze(d) is d

    def test_freeze_non_collection(self):
        assert ct._freeze(42) == 42
        assert ct._freeze("abc") == "abc"

    def test_empty(self):
        d = ct.FrozenDict()
        assert len(d) == 0
        assert list(d) == []

    def test_nested_immutability(self):
        d = ct.FrozenDict({"a": {"b": [1, 2]}})
        with pytest.raises(TypeError):
            d["a"]["b"] = 3
        with pytest.raises(TypeError):
            d["a"]["b"][0] = 99

    def test_repr(self):
        d = ct.FrozenDict({"x": 1})
        assert "FrozenDict" in repr(d)