"""Tests for Faker providers."""

import pytest
from faker import Faker
from testdatagen.providers.testdata_provider import TestDataProvider


class TestTestDataProvider:
    """Tests for TestDataProvider class."""

    def test_json_schema_type_boolean(self):
        """Test boolean type generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({"type": "boolean"}, faker)
        assert isinstance(result, bool)

    def test_json_schema_type_integer(self):
        """Test integer type generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({"type": "integer"}, faker)
        assert isinstance(result, int)

    def test_json_schema_type_integer_with_constraints(self):
        """Test integer with min/max constraints."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({
            "type": "integer",
            "minimum": 10,
            "maximum": 20
        }, faker)
        
        assert isinstance(result, int)
        assert 10 <= result <= 20

    def test_json_schema_type_number(self):
        """Test number type generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({"type": "number"}, faker)
        assert isinstance(result, float)

    def test_json_schema_type_string(self):
        """Test string type generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({"type": "string"}, faker)
        assert isinstance(result, str)

    def test_json_schema_type_string_email(self):
        """Test email format generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({
            "type": "string",
            "format": "email"
        }, faker)
        
        assert "@" in result
        assert "." in result

    def test_json_schema_type_string_uuid(self):
        """Test UUID format generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({
            "type": "string",
            "format": "uuid"
        }, faker)
        
        assert len(result) == 36

    def test_json_schema_type_string_uri(self):
        """Test URI format generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({
            "type": "string",
            "format": "uri"
        }, faker)
        
        assert "://" in result

    def test_json_schema_type_enum(self):
        """Test enum generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({
            "enum": ["red", "green", "blue"]
        }, faker)
        
        assert result in ["red", "green", "blue"]

    def test_json_schema_type_null(self):
        """Test null type generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({"type": "null"}, faker)
        assert result is None

    def test_json_schema_type_const(self):
        """Test const generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({"const": "fixed_value"}, faker)
        assert result == "fixed_value"

    def test_json_schema_type_array(self):
        """Test array generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({
            "type": "array",
            "items": {"type": "string"}
        }, faker)
        
        assert isinstance(result, list)

    def test_json_schema_type_object(self):
        """Test object generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({
            "type": "object",
            "properties": {
                "name": {"type": "string"}
            }
        }, faker)
        
        assert isinstance(result, dict)
        assert "name" in result

    def test_generate_from_pattern_simple(self):
        """Test pattern-based generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider._generate_from_pattern(r"\d{3}")
        assert len(result) == 3
        assert result.isdigit()

    def test_generate_from_pattern_alphanumeric(self):
        """Test alphanumeric pattern generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider._generate_from_pattern(r"\w+")
        assert isinstance(result, str)

    def test_generate_from_pattern_complex(self):
        """Test complex pattern generation."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider._generate_from_pattern(r"[abc]{3}")
        assert len(result) == 3
        assert all(c in "abc" for c in result)

    def test_any_of_schema(self):
        """Test anyOf schema handling."""
        faker = Faker()
        provider = TestDataProvider(faker)
        
        result = provider.json_schema_type({
            "anyOf": [
                {"type": "string", "format": "email"},
                {"type": "string", "format": "uri"}
            ]
        }, faker)
        
        assert isinstance(result, str)