"""Unit tests for type validators."""

import pytest

from envschema.schema import EnvVarType
from envschema.validators import (
    StringValidator,
    IntegerValidator,
    BooleanValidator,
    ListValidator,
    PatternValidator,
    validate_value,
)


class TestStringValidator:
    """Tests for StringValidator."""

    def test_valid_string(self):
        is_valid, error = StringValidator.validate("any value")
        assert is_valid is True
        assert error is None

    def test_empty_string(self):
        is_valid, error = StringValidator.validate("")
        assert is_valid is True
        assert error is None

    def test_none_value(self):
        is_valid, error = StringValidator.validate(None)
        assert is_valid is True
        assert error is None


class TestIntegerValidator:
    """Tests for IntegerValidator."""

    def test_valid_integer(self):
        is_valid, error = IntegerValidator.validate("42")
        assert is_valid is True
        assert error is None

    def test_valid_negative_integer(self):
        is_valid, error = IntegerValidator.validate("-10")
        assert is_valid is True
        assert error is None

    def test_valid_zero(self):
        is_valid, error = IntegerValidator.validate("0")
        assert is_valid is True
        assert error is None

    def test_invalid_float(self):
        is_valid, error = IntegerValidator.validate("3.14")
        assert is_valid is False
        assert error is not None

    def test_invalid_string(self):
        is_valid, error = IntegerValidator.validate("abc")
        assert is_valid is False
        assert error is not None

    def test_none_value(self):
        is_valid, error = IntegerValidator.validate(None)
        assert is_valid is True
        assert error is None


class TestBooleanValidator:
    """Tests for BooleanValidator."""

    @pytest.mark.parametrize("value", ["true", "True", "TRUE", "1", "yes", "Yes", "YES", "on", "ON"])
    def test_valid_true_values(self, value):
        is_valid, error = BooleanValidator.validate(value)
        assert is_valid is True
        assert error is None

    @pytest.mark.parametrize("value", ["false", "False", "FALSE", "0", "no", "No", "NO", "off", "OFF"])
    def test_valid_false_values(self, value):
        is_valid, error = BooleanValidator.validate(value)
        assert is_valid is True
        assert error is None

    @pytest.mark.parametrize("value", ["maybe", "2", "truee", "yess"])
    def test_invalid_boolean_values(self, value):
        is_valid, error = BooleanValidator.validate(value)
        assert is_valid is False
        assert error is not None

    def test_none_value(self):
        is_valid, error = BooleanValidator.validate(None)
        assert is_valid is True
        assert error is None


class TestListValidator:
    """Tests for ListValidator."""

    def test_valid_list(self):
        is_valid, error = ListValidator.validate("item1,item2,item3")
        assert is_valid is True
        assert error is None

    def test_single_item_list(self):
        is_valid, error = ListValidator.validate("single")
        assert is_valid is False
        assert error is not None

    def test_empty_string(self):
        is_valid, error = ListValidator.validate("")
        assert is_valid is False

    def test_none_value(self):
        is_valid, error = ListValidator.validate(None)
        assert is_valid is True
        assert error is None

    def test_parse_list(self):
        result = ListValidator.parse("item1, item2 , item3")
        assert result == ["item1", "item2", "item3"]

    def test_parse_list_with_empty_items(self):
        result = ListValidator.parse("item1,,item2")
        assert result == ["item1", "item2"]


class TestPatternValidator:
    """Tests for PatternValidator."""

    def test_valid_pattern_match(self):
        is_valid, error = PatternValidator.validate("ABC123", r"^[A-Z]+[0-9]+$")
        assert is_valid is True
        assert error is None

    def test_invalid_pattern_match(self):
        is_valid, error = PatternValidator.validate("abc123", r"^[A-Z]+[0-9]+$")
        assert is_valid is False
        assert error is not None

    def test_invalid_regex_pattern(self):
        is_valid, error = PatternValidator.validate("test", r"[invalid")
        assert is_valid is False
        assert error is not None

    def test_none_value(self):
        is_valid, error = PatternValidator.validate(None, r"^[A-Z]+$")
        assert is_valid is True
        assert error is None


class TestValidateValue:
    """Tests for the main validate_value function."""

    def test_validate_string(self):
        is_valid, error = validate_value("test", EnvVarType.STRING)
        assert is_valid is True

    def test_validate_integer(self):
        is_valid, error = validate_value("42", EnvVarType.INTEGER)
        assert is_valid is True

    def test_validate_boolean(self):
        is_valid, error = validate_value("true", EnvVarType.BOOLEAN)
        assert is_valid is True

    def test_validate_list(self):
        is_valid, error = validate_value("a,b,c", EnvVarType.LIST)
        assert is_valid is True

    def test_validate_with_pattern(self):
        is_valid, error = validate_value("ABC123", EnvVarType.STRING, r"^[A-Z]+[0-9]+$")
        assert is_valid is True

    def test_validate_with_invalid_pattern(self):
        is_valid, error = validate_value("abc123", EnvVarType.STRING, r"^[A-Z]+[0-9]+$")
        assert is_valid is False