"""Tests for BooleanFilter utility enum."""

import unittest

from abacus_common_logic.utils.request import BooleanFilter


class TestBooleanFilter(unittest.TestCase):
    """Tests for BooleanFilter."""

    def test_parse_none(self):
        """Test parsing of None."""
        self.assertIs(BooleanFilter.parse(None), None)

    def test_parse_none_uses_default(self):
        """Test parsing of None with default."""
        self.assertIs(BooleanFilter.parse(None, BooleanFilter.ALL), BooleanFilter.ALL)
        self.assertIs(BooleanFilter.parse(None, BooleanFilter.TRUE), BooleanFilter.TRUE)
        self.assertIs(
            BooleanFilter.parse(None, BooleanFilter.FALSE), BooleanFilter.FALSE
        )

    def test_parse_bool_true_returns_TRUE(self):
        """Test parsing of boolean True."""
        self.assertIs(BooleanFilter.parse(True), BooleanFilter.TRUE)

    def test_parse_bool_false_returns_FALSE(self):
        """Test parsing of boolean False."""
        self.assertIs(BooleanFilter.parse(False), BooleanFilter.FALSE)

    def test_parse_bool_with_default(self):
        """Test parsing of boolean values with default."""
        self.assertIs(
            BooleanFilter.parse(True, default=BooleanFilter.FALSE), BooleanFilter.TRUE
        )
        self.assertIs(
            BooleanFilter.parse(False, default=BooleanFilter.TRUE), BooleanFilter.FALSE
        )

    def test_parse_empty_string_and_whitespace(self):
        """Test parsing of valid values with leading / trailing whitespace."""
        self.assertIs(BooleanFilter.parse('   true   '), BooleanFilter.TRUE)
        self.assertIs(BooleanFilter.parse('\t\nfalse\r\n'), BooleanFilter.FALSE)
        self.assertIs(BooleanFilter.parse('  all '), BooleanFilter.ALL)

    def test_parse_truthy_variants(self):
        """Test parsing for valid TRUE values."""
        for val in ['1', 'on', 't', 'true', 'y', 'yes']:
            with self.subTest(val=val):
                self.assertIs(BooleanFilter.parse(val), BooleanFilter.TRUE)

    def test_parse_truthy_variants_case_insensitive(self):
        """Test case insensitive parsing for valid TRUE values."""
        for val in ['1', 'oN', 'T', 'TrUe', 'Y', 'yeS']:
            with self.subTest(val=val):
                self.assertIs(BooleanFilter.parse(val), BooleanFilter.TRUE)

    def test_parse_falsy_variants(self):
        """Test parsing for valid FALSE values."""
        for val in ['0', 'f', 'false', 'n', 'no', 'off']:
            with self.subTest(val=val):
                self.assertIs(BooleanFilter.parse(val), BooleanFilter.FALSE)

    def test_parse_falsy_variants_case_insensitive(self):
        """Test case insensitive parsing for valid FALSE values."""
        for val in ['0', 'F', 'faLsE', 'N', 'nO', 'oFf']:
            with self.subTest(val=val):
                self.assertIs(BooleanFilter.parse(val), BooleanFilter.FALSE)

    def test_parse_all_variants(self):
        """Test parsing for valid ALL values."""
        for val in ['*', 'all']:
            with self.subTest(val=val):
                self.assertIs(BooleanFilter.parse(val), BooleanFilter.ALL)

    def test_parse_all_variants_case_insensitive(self):
        """Test case insensitive parsing for valid ALL values."""
        for val in ['*', 'ALl']:
            with self.subTest(val=val):
                self.assertIs(BooleanFilter.parse(val), BooleanFilter.ALL)

    def test_to_bool(self):
        """Test to_bool."""
        self.assertTrue(BooleanFilter.TRUE.to_bool())
        self.assertFalse(BooleanFilter.FALSE.to_bool())
        self.assertIsNone(BooleanFilter.ALL.to_bool())

    def test_to_bool_with_bool_inputs(self):
        """Test parsing of boolean values."""
        # Ensures consistency, even though to_bool always operates on enum members
        self.assertTrue(BooleanFilter.parse(True).to_bool())
        self.assertFalse(BooleanFilter.parse(False).to_bool())

    def test_serialize_alias_returns_bool_or_none(self):
        """Test _serialize."""
        self.assertTrue(BooleanFilter.TRUE._serialize())
        self.assertFalse(BooleanFilter.FALSE._serialize())
        self.assertIsNone(BooleanFilter.ALL._serialize())

    def test_serialize_with_bool_inputs(self):
        """Test parsing of boolean values."""
        # Ensures consistency, even though _serialize always operates on enum members
        self.assertTrue(BooleanFilter.parse(True)._serialize())
        self.assertFalse(BooleanFilter.parse(False)._serialize())

    def test_parse_with_default(self):
        """Test parsing a valid value with default."""
        self.assertIs(
            BooleanFilter.parse('false', BooleanFilter.TRUE), BooleanFilter.FALSE
        )
        self.assertIs(
            BooleanFilter.parse('yes', BooleanFilter.FALSE), BooleanFilter.TRUE
        )

    def test_parse_invalid_with_default_raises(self):
        """Test parse invalid value."""
        with self.assertRaises(ValueError):
            BooleanFilter.parse('unknown', BooleanFilter.TRUE)

    def test_parse_invalid_raises_value_error(self):
        """Test parse invalid values."""
        for val in ['maybe', '2', '', '   ', 'truthy', ' fals']:
            with self.subTest(val=val):
                with self.assertRaises(ValueError):
                    BooleanFilter.parse(val)

    def test_identity_round_trip(self):
        """Test round trip conversion."""
        for bf in BooleanFilter:
            # simulate round-trip via string
            parsed = BooleanFilter.parse(bf.value)
            self.assertIs(parsed, bf)
            self.assertEqual(parsed.value, bf.value)