"""Tests for schemas.enums — normalize, BooleanValue, enum types."""

import pytest

from schemas import (
    CONTRACT_TYPE_ALIASES,
    PERIOD_TYPE_ALIASES,
    RENEWAL_TYPE_ALIASES,
    BooleanValue,
    ContractType,
    PeriodType,
    RenewalType,
    resolve_enum,
)


class TestResolveEnum:
    def test_direct_match(self):
        assert (
            resolve_enum('distribution', ContractType, CONTRACT_TYPE_ALIASES)
            == ContractType.DISTRIBUTION
        )

    def test_alias_match(self):
        assert (
            resolve_enum('legacy distribution', ContractType, CONTRACT_TYPE_ALIASES)
            == ContractType.LEGACY_DISTRIBUTION
        )

    def test_case_insensitive(self):
        assert (
            resolve_enum('DISTRIBUTION', ContractType, CONTRACT_TYPE_ALIASES)
            == ContractType.DISTRIBUTION
        )

    def test_strips_whitespace(self):
        assert (
            resolve_enum('  distribution  ', ContractType, CONTRACT_TYPE_ALIASES)
            == ContractType.DISTRIBUTION
        )

    def test_na_returns_none(self):
        assert resolve_enum('N/A', PeriodType, PERIOD_TYPE_ALIASES) is None

    def test_unknown_returns_none(self):
        assert resolve_enum('bogus', ContractType, CONTRACT_TYPE_ALIASES) is None

    def test_empty_returns_none(self):
        assert resolve_enum('', ContractType, CONTRACT_TYPE_ALIASES) is None

    def test_period_alias_days(self):
        assert resolve_enum('days', PeriodType, PERIOD_TYPE_ALIASES) == PeriodType.DAY

    def test_renewal_alias_space_separated(self):
        assert (
            resolve_enum('continuously active', RenewalType, RENEWAL_TYPE_ALIASES)
            == RenewalType.CONTINUOUSLY_ACTIVE
        )


class TestBooleanValue:
    @pytest.mark.parametrize(
        'value', ['yes', 'Yes', 'YES', 'true', 'True', '1', 'y', 'on']
    )
    def test_truthy(self, value):
        assert (
            BooleanValue.parse(value, default=BooleanValue.FALSE) == BooleanValue.TRUE
        )

    @pytest.mark.parametrize(
        'value', ['no', 'No', 'NO', 'false', 'False', '0', 'n', 'off']
    )
    def test_falsy(self, value):
        assert (
            BooleanValue.parse(value, default=BooleanValue.TRUE) == BooleanValue.FALSE
        )

    def test_none_returns_default(self):
        assert BooleanValue.parse(None, default=BooleanValue.TRUE) == BooleanValue.TRUE

    def test_empty_returns_default(self):
        assert BooleanValue.parse('', default=BooleanValue.FALSE) == BooleanValue.FALSE

    def test_whitespace_returns_default(self):
        assert BooleanValue.parse('   ', default=BooleanValue.TRUE) == BooleanValue.TRUE

    def test_invalid_raises(self):
        with pytest.raises(ValueError, match='Invalid boolean value'):
            BooleanValue.parse('maybe', default=BooleanValue.FALSE)

    def test_to_bool_true(self):
        assert BooleanValue.TRUE.to_bool() is True

    def test_to_bool_false(self):
        assert BooleanValue.FALSE.to_bool() is False