"""Tests for TypeScript generator."""

from config_converter.generators import TypeScriptGenerator
from config_converter.validators.schema import SchemaType


class TestTypeScriptGenerator:
    """Tests for TypeScript interface generation."""

    def test_generate_simple_interface(self) -> None:
        """Test generating simple interface."""
        generator = TypeScriptGenerator(interface_name="TestConfig")
        data = {"name": "test", "value": 42}
        result = generator.generate(data)
        assert "export interface TestConfig" in result
        assert "name: string" in result
        assert "value: number" in result

    def test_generate_with_boolean(self) -> None:
        """Test generating interface with boolean property."""
        generator = TypeScriptGenerator()
        data = {"active": True, "disabled": False}
        result = generator.generate(data)
        assert "active: boolean" in result
        assert "disabled: boolean" in result

    def test_generate_with_nested_object(self) -> None:
        """Test generating interface with nested object."""
        generator = TypeScriptGenerator()
        data = {"config": {"setting": "value"}}
        result = generator.generate(data)
        assert "export interface Config" in result
        assert "setting: string" in result

    def test_generate_with_array(self) -> None:
        """Test generating interface with array."""
        generator = TypeScriptGenerator()
        data = {"items": [1, 2, 3]}
        result = generator.generate(data)
        assert "items: Array<number>" in result

    def test_generate_with_array_of_objects(self) -> None:
        """Test generating interface with array of objects."""
        generator = TypeScriptGenerator()
        data = {"users": [{"name": "Alice"}, {"name": "Bob"}]}
        result = generator.generate(data)
        assert "users: UsersItem[]" in result or "Array<" in result

    def test_generate_from_schema(self) -> None:
        """Test generating from inferred schema."""
        from config_converter.validators import SchemaInferrer

        generator = TypeScriptGenerator()
        data = {"name": "test", "count": 5}
        inferrer = SchemaInferrer()
        schema = inferrer.infer(data)
        result = generator.generate_from_schema(schema, "GeneratedConfig")
        assert "export interface GeneratedConfig" in result

    def test_python_to_ts_mapping(self) -> None:
        """Test Python to TypeScript type mapping."""
        generator = TypeScriptGenerator()
        mapping = generator.PYTHON_TO_TS
        assert mapping[SchemaType.STRING] == "string"
        assert mapping[SchemaType.NUMBER] == "number"
        assert mapping[SchemaType.INTEGER] == "number"
        assert mapping[SchemaType.BOOLEAN] == "boolean"
        assert mapping[SchemaType.NULL] == "null"

    def test_generate_custom_interface_name(self) -> None:
        """Test generating with custom interface name."""
        generator = TypeScriptGenerator(interface_name="CustomName")
        result = generator.generate({"key": "value"})
        assert "export interface CustomName" in result

    def test_generate_from_json_string(self) -> None:
        """Test generating TypeScript from JSON string."""
        generator = TypeScriptGenerator()
        json_str = '{"name": "test", "value": 42}'
        result = generator.generate_from_json(json_str)
        assert "export interface Config" in result
        assert "name: string" in result