from __future__ import annotations

import pytest

from daglib.set import DAGSet


class TestDAGSetInit:
    """Test DAGSet initialization."""

    def test_init_empty(self) -> None:
        s = DAGSet()
        assert len(s) == 0
        assert list(s) == []

    def test_init_from_set(self) -> None:
        s = DAGSet({1, 2, 3})
        assert len(s) == 3
        assert set(s) == {1, 2, 3}

    def test_init_from_list(self) -> None:
        s = DAGSet([1, 2, 3, 2])
        assert len(s) == 3
        assert set(s) == {1, 2, 3}

    def test_init_from_tuple(self) -> None:
        s = DAGSet((4, 5, 6))
        assert len(s) == 3
        assert 4 in s and 5 in s and 6 in s

    def test_init_none(self) -> None:
        s = DAGSet(None)
        assert len(s) == 0

    def test_init_invalid_type(self) -> None:
        with pytest.raises(TypeError):
            DAGSet(42)  # type: ignore


class TestDAGSetBasicOps:
    """Test basic set operations."""

    def test_contains(self) -> None:
        s = DAGSet({1, 2, 3})
        assert 1 in s
        assert 4 not in s

    def test_add(self) -> None:
        s = DAGSet()
        s.add(1)
        assert 1 in s
        assert len(s) == 1

    def test_discard(self) -> None:
        s = DAGSet({1, 2, 3})
        s.discard(2)
        assert 2 not in s
        assert len(s) == 2

    def test_discard_missing(self) -> None:
        s = DAGSet({1, 2, 3})
        s.discard(99)  # should not raise
        assert len(s) == 3

    def test_remove(self) -> None:
        s = DAGSet({1, 2, 3})
        s.remove(2)
        assert 2 not in s

    def test_remove_missing(self) -> None:
        s = DAGSet({1, 2, 3})
        with pytest.raises(KeyError):
            s.remove(99)

    def test_iter(self) -> None:
        s = DAGSet({1, 2, 3})
        items = set(s)
        assert items == {1, 2, 3}

    def test_len(self) -> None:
        s = DAGSet({1, 2, 3})
        assert len(s) == 3


class TestDAGSetCallbacks:
    """Test callback mechanisms."""

    def test_on_add_callback(self) -> None:
        added: list[int] = []
        s = DAGSet({1, 2})
        s.on_add = lambda v: added.append(v)
        s.add(3)
        assert 3 in added
        assert len(added) == 1

    def test_on_remove_callback(self) -> None:
        removed: list[int] = []
        s = DAGSet({1, 2, 3})
        s.on_remove = lambda v: removed.append(v)
        s.discard(2)
        assert 2 in removed
        assert len(removed) == 1

    def test_callbacks_none_by_default(self) -> None:
        s = DAGSet()
        assert s.on_add is None
        assert s.on_remove is None


class TestDAGSetInPlaceOperators:
    """Test in-place set operators."""

    def test_ior_with_set(self) -> None:
        s = DAGSet({1, 2})
        s |= {3, 4}
        assert set(s) == {1, 2, 3, 4}

    def test_ior_with_list(self) -> None:
        s = DAGSet({1})
        s |= [2, 3]
        assert set(s) == {1, 2, 3}

    def test_ior_with_string(self) -> None:
        s = DAGSet({"a", "b"})
        s |= "c"
        assert "c" in s

    def test_iadd_with_set(self) -> None:
        s = DAGSet({1, 2})
        s += {3, 4}
        assert set(s) == {1, 2, 3, 4}

    def test_iadd_with_list(self) -> None:
        s = DAGSet({1})
        s += [2, 3]
        assert set(s) == {1, 2, 3}

    def test_iadd_with_string(self) -> None:
        s = DAGSet({"a"})
        s += "b"
        assert "b" in s

    def test_isub_with_set(self) -> None:
        s = DAGSet({1, 2, 3, 4})
        s -= {2, 3}
        assert set(s) == {1, 4}

    def test_isub_with_list(self) -> None:
        s = DAGSet({1, 2, 3})
        s -= [2]
        assert set(s) == {1, 3}

    def test_isub_with_string(self) -> None:
        s = DAGSet({"a", "b", "c"})
        s -= "b"
        assert set(s) == {"a", "c"}

    def test_iand_with_set(self) -> None:
        s = DAGSet({1, 2, 3})
        s &= {2, 3, 4}
        assert set(s) == {2, 3}

    def test_iand_with_list(self) -> None:
        s = DAGSet({1, 2, 3})
        s &= [2, 3]
        assert set(s) == {2, 3}

    def test_ixor_with_set(self) -> None:
        s = DAGSet({1, 2, 3})
        s ^= {3, 4, 5}
        assert set(s) == {1, 2, 4, 5}

    def test_ixor_with_list(self) -> None:
        s = DAGSet({1, 2})
        s ^= [2, 3]
        assert set(s) == {1, 3}


class TestDAGSetCallbacksWithOperators:
    """Test that callbacks fire with in-place operators."""

    def test_ior_triggers_callbacks(self) -> None:
        added: list[int] = []
        s = DAGSet({1})
        s.on_add = lambda v: added.append(v)
        s |= {2, 3}
        assert 2 in added
        assert 3 in added

    def test_iadd_triggers_callbacks(self) -> None:
        added: list[int] = []
        s = DAGSet({1})
        s.on_add = lambda v: added.append(v)
        s += [2, 3]
        assert 2 in added
        assert 3 in added

    def test_isub_triggers_callbacks(self) -> None:
        removed: list[int] = []
        s = DAGSet({1, 2, 3})
        s.on_remove = lambda v: removed.append(v)
        s -= {2, 3}
        assert 2 in removed
        assert 3 in removed


class TestDAGSetRepr:
    """Test string representation."""

    def test_repr_empty(self) -> None:
        s = DAGSet()
        assert repr(s) == "{}"

    def test_repr_with_items(self) -> None:
        s = DAGSet({1, 2, 3})
        r = repr(s)
        assert r.startswith("{")
        assert r.endswith("}")
        # items may be in any order
        assert "1" in r
        assert "2" in r
        assert "3" in r