"""Tests for Response Generator."""

import pytest
from src.core.generator import ResponseGenerator, UnsupportedSchemaType


class TestResponseGenerator:
    """Tests for ResponseGenerator class."""

    def test_generate_string(self):
        """Test string generation."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "string"}
        result = generator.generate(schema)

        assert isinstance(result, str)
        assert len(result) > 0

    def test_generate_string_with_min_length(self):
        """Test string generation with minLength constraint."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "string", "minLength": 50}
        result = generator.generate(schema)

        assert isinstance(result, str)
        assert len(result) >= 50

    def test_generate_string_with_max_length(self):
        """Test string generation with maxLength constraint."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "string", "maxLength": 10}
        result = generator.generate(schema)

        assert isinstance(result, str)
        assert len(result) <= 10

    def test_generate_string_with_enum(self):
        """Test string generation with enum constraint."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "string", "enum": ["apple", "banana", "cherry"]}
        result = generator.generate(schema)

        assert result in ["apple", "banana", "cherry"]

    def test_generate_string_with_format_email(self):
        """Test string generation with email format."""
        generator = ResponseGenerator(seed=42)

        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 string generation with UUID format."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "string", "format": "uuid"}
        result = generator.generate(schema)

        assert isinstance(result, str)

    def test_generate_integer(self):
        """Test integer generation."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "integer"}
        result = generator.generate(schema)

        assert isinstance(result, int)

    def test_generate_integer_with_bounds(self):
        """Test integer generation with minimum and maximum."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "integer", "minimum": 10, "maximum": 20}
        result = generator.generate(schema)

        assert isinstance(result, int)
        assert 10 <= result <= 20

    def test_generate_integer_with_multiple_of(self):
        """Test integer generation with multipleOf constraint."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "integer", "minimum": 0, "maximum": 100, "multipleOf": 5}
        result = generator.generate(schema)

        assert isinstance(result, int)
        assert result % 5 == 0

    def test_generate_number(self):
        """Test number generation."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "number"}
        result = generator.generate(schema)

        assert isinstance(result, float)

    def test_generate_boolean(self):
        """Test boolean generation."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "boolean"}
        result = generator.generate(schema)

        assert isinstance(result, bool)

    def test_generate_object(self):
        """Test object generation."""
        generator = ResponseGenerator(seed=42)

        schema = {
            "type": "object",
            "properties": {
                "id": {"type": "integer"},
                "name": {"type": "string"},
                "email": {"type": "string", "format": "email"}
            },
            "required": ["id", "name"]
        }
        result = generator.generate(schema)

        assert isinstance(result, dict)
        assert "id" in result
        assert "name" in result
        assert isinstance(result["id"], int)
        assert isinstance(result["name"], str)

    def test_generate_object_with_nested_properties(self):
        """Test object generation with nested properties."""
        generator = ResponseGenerator(seed=42)

        schema = {
            "type": "object",
            "properties": {
                "user": {
                    "type": "object",
                    "properties": {
                        "id": {"type": "integer"},
                        "name": {"type": "string"}
                    }
                }
            }
        }
        result = generator.generate(schema)

        assert isinstance(result, dict)
        assert "user" in result
        assert isinstance(result["user"], dict)
        assert "id" in result["user"]
        assert "name" in result["user"]

    def test_generate_null(self):
        """Test null generation."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "null"}
        result = generator.generate(schema)

        assert result is None

    def test_generate_empty_schema(self):
        """Test handling of empty schema."""
        generator = ResponseGenerator(seed=42)

        result = generator.generate({})

        assert result is None

    def test_generate_none_schema(self):
        """Test handling of None schema."""
        generator = ResponseGenerator(seed=42)

        result = generator.generate(None)

        assert result is None

    def test_generate_response(self):
        """Test generating a complete response."""
        generator = ResponseGenerator(seed=42)

        schema = {"type": "object", "properties": {"id": {"type": "integer"}, "name": {"type": "string"}}}
        response = generator.generate_response(schema, status_code=200, headers={"Content-Type": "application/json"})

        assert response["status_code"] == 200
        assert response["body"] is not None
        assert response["headers"]["Content-Type"] == "application/json"

    def test_generate_list_response(self):
        """Test generating a list response."""
        generator = ResponseGenerator(seed=42)

        item_schema = {"type": "object", "properties": {"id": {"type": "integer"}, "name": {"type": "string"}}}
        response = generator.generate_list_response(item_schema, count=5)

        assert response["status_code"] == 200
        assert isinstance(response["body"], list)
        assert len(response["body"]) == 5

    def test_generate_error_response(self):
        """Test generating an error response."""
        generator = ResponseGenerator(seed=42)

        response = generator.generate_error_response("Not found", status_code=404, error_type="Not Found")

        assert response["status_code"] == 404
        assert response["body"]["error"]["type"] == "Not Found"
        assert response["body"]["error"]["message"] == "Not found"


class TestResponseGeneratorErrors:
    """Tests for response generator error handling."""

    def test_unsupported_schema_type(self):
        """Test handling of unsupported schema type."""
        generator = ResponseGenerator(seed=42)

        with pytest.raises(UnsupportedSchemaType):
            generator.generate({"type": "unsupported_type"})