"""Tests for the data generator module."""

import pytest

from openapi_mock.generators.data_generator import (
    DataGenerator,
    generate_mock_data,
    FakerMapping,
    UnsupportedTypeError,
)


class TestFakerMapping:
    """Tests for FakerMapping class."""

    def test_get_faker_method_by_format(self):
        """Test getting Faker method by format."""
        schema = {"type": "string", "format": "email"}
        method = FakerMapping.get_faker_method(schema)
        assert method == "email"

    def test_get_faker_method_by_type(self):
        """Test getting Faker method by type."""
        schema = {"type": "integer"}
        method = FakerMapping.get_faker_method(schema)
        assert method == "random_int"

    def test_get_faker_method_default(self):
        """Test getting default Faker method."""
        schema = {"type": "unknown"}
        method = FakerMapping.get_faker_method(schema)
        assert method == "word"


class TestDataGenerator:
    """Tests for DataGenerator class."""

    def test_generate_string(self):
        """Test generating a string."""
        generator = DataGenerator()
        schema = {"type": "string"}
        result = generator.generate(schema)
        assert isinstance(result, str)

    def test_generate_integer(self):
        """Test generating an integer."""
        generator = DataGenerator()
        schema = {"type": "integer"}
        result = generator.generate(schema)
        assert isinstance(result, int)

    def test_generate_boolean(self):
        """Test generating a boolean."""
        generator = DataGenerator()
        schema = {"type": "boolean"}
        result = generator.generate(schema)
        assert isinstance(result, bool)

    def test_generate_number(self):
        """Test generating a number."""
        generator = DataGenerator()
        schema = {"type": "number"}
        result = generator.generate(schema)
        assert isinstance(result, float)

    def test_generate_string_with_format_email(self):
        """Test generating an email."""
        generator = DataGenerator()
        schema = {"type": "string", "format": "email"}
        result = generator.generate(schema)
        assert isinstance(result, str)
        assert "@" in result

    def test_generate_string_with_format_uuid(self):
        """Test generating a UUID."""
        generator = DataGenerator()
        schema = {"type": "string", "format": "uuid"}
        result = generator.generate(schema)
        assert isinstance(result, str)

    def test_generate_string_with_format_date_time(self):
        """Test generating a date-time."""
        generator = DataGenerator()
        schema = {"type": "string", "format": "date-time"}
        result = generator.generate(schema)
        assert isinstance(result, str)

    def test_generate_string_with_enum(self):
        """Test generating from enum values."""
        generator = DataGenerator()
        schema = {"type": "string", "enum": ["red", "green", "blue"]}
        result = generator.generate(schema)
        assert result in ["red", "green", "blue"]

    def test_generate_string_with_min_max_length(self):
        """Test generating string with length constraints."""
        generator = DataGenerator()
        schema = {"type": "string", "minLength": 10, "maxLength": 20}
        result = generator.generate(schema)
        assert len(result) >= 10
        assert len(result) <= 20

    def test_generate_integer_with_min_max(self):
        """Test generating integer with min/max."""
        generator = DataGenerator()
        schema = {"type": "integer", "minimum": 10, "maximum": 20}
        result = generator.generate(schema)
        assert result >= 10
        assert result <= 20

    def test_generate_integer_with_multiple_of(self):
        """Test generating integer with multipleOf."""
        generator = DataGenerator()
        schema = {"type": "integer", "minimum": 0, "maximum": 100, "multipleOf": 5}
        result = generator.generate(schema)
        assert result % 5 == 0

    def test_generate_object(self):
        """Test generating an object."""
        generator = DataGenerator()
        schema = {
            "type": "object",
            "properties": {
                "name": {"type": "string"},
                "age": {"type": "integer"}
            }
        }
        result = generator.generate(schema)
        assert isinstance(result, dict)
        assert "name" in result or "age" in result

    def test_generate_array(self):
        """Test generating an array."""
        generator = DataGenerator()
        schema = {
            "type": "array",
            "items": {"type": "string"},
            "minItems": 2,
            "maxItems": 5
        }
        result = generator.generate(schema)
        assert isinstance(result, list)
        assert len(result) >= 2
        assert len(result) <= 5

    def test_generate_with_ref(self, sample_openapi_spec):
        """Test generating with $ref."""
        generator = DataGenerator()
        schemas = sample_openapi_spec["components"]["schemas"]
        generator.set_ref_cache(schemas)

        schema = {"$ref": "#/components/schemas/User"}
        result = generator.generate(schema)
        assert isinstance(result, dict)

    def test_generate_null(self):
        """Test generating null value."""
        generator = DataGenerator()
        schema = {"type": "null"}
        result = generator.generate(schema)
        assert result is None

    def test_generate_nullable(self):
        """Test generating nullable field."""
        generator = DataGenerator()
        schema = {"type": "string", "nullable": True}
        result = generator.generate(schema)
        assert result is None or isinstance(result, str)


class TestGenerateMockData:
    """Tests for the convenience function."""

    def test_generate_mock_data_simple(self):
        """Test generating mock data with convenience function."""
        schema = {"type": "string", "format": "email"}
        result = generate_mock_data(schema)
        assert isinstance(result, str)
        assert "@" in result

    def test_generate_mock_data_with_schemas(self, sample_openapi_spec):
        """Test generating mock data with schemas."""
        schemas = sample_openapi_spec["components"]["schemas"]
        schema = {"$ref": "#/components/schemas/User"}
        result = generate_mock_data(schema, schemas=schemas)
        assert isinstance(result, dict)

    def test_generate_nested_object(self):
        """Test generating nested object."""
        schema = {
            "type": "object",
            "properties": {
                "user": {
                    "type": "object",
                    "properties": {
                        "name": {"type": "string"},
                        "email": {"type": "string", "format": "email"}
                    }
                }
            }
        }
        result = generate_mock_data(schema)
        assert isinstance(result, dict)