"""Tests for models module."""

import pytest

from codexchange.models import (
    Language,
    ConversionRequest,
    ConversionResult,
    ModelInfo,
    FileConversionResult,
    VALID_CONVERSIONS,
)


class TestLanguage:
    """Tests for Language enum."""

    def test_language_values(self):
        """Test that Language enum has correct values."""
        assert Language.JAVASCRIPT.value == "javascript"
        assert Language.TYPESCRIPT.value == "typescript"
        assert Language.PYTHON.value == "python"
        assert Language.JAVA.value == "java"

    def test_from_extension(self):
        """Test getting language from file extension."""
        assert Language.from_extension(".js") == Language.JAVASCRIPT
        assert Language.from_extension(".jsx") == Language.JAVASCRIPT
        assert Language.from_extension(".ts") == Language.TYPESCRIPT
        assert Language.from_extension(".tsx") == Language.TYPESCRIPT
        assert Language.from_extension(".py") == Language.PYTHON
        assert Language.from_extension(".java") == Language.JAVA
        assert Language.from_extension(".unknown") is None

    def test_extension_property(self):
        """Test getting file extension from language."""
        assert Language.JAVASCRIPT.extension == ".js"
        assert Language.TYPESCRIPT.extension == ".ts"
        assert Language.PYTHON.extension == ".py"
        assert Language.JAVA.extension == ".java"

    def test_syntax_check_command(self):
        """Test syntax check command property."""
        assert Language.PYTHON.syntax_check_command == "python"
        assert Language.TYPESCRIPT.syntax_check_command is not None
        assert Language.JAVASCRIPT.syntax_check_command is not None
        assert Language.JAVA.syntax_check_command is None


class TestValidConversions:
    """Tests for valid conversion pairs."""

    def test_js_ts_conversion(self):
        """Test JavaScript to TypeScript conversion is valid."""
        assert (Language.JAVASCRIPT, Language.TYPESCRIPT) in VALID_CONVERSIONS
        assert (Language.TYPESCRIPT, Language.JAVASCRIPT) in VALID_CONVERSIONS

    def test_js_python_conversion(self):
        """Test JavaScript to Python conversion is valid."""
        assert (Language.JAVASCRIPT, Language.PYTHON) in VALID_CONVERSIONS
        assert (Language.PYTHON, Language.JAVASCRIPT) in VALID_CONVERSIONS

    def test_ts_python_conversion(self):
        """Test TypeScript to Python conversion is valid."""
        assert (Language.TYPESCRIPT, Language.PYTHON) in VALID_CONVERSIONS
        assert (Language.PYTHON, Language.TYPESCRIPT) in VALID_CONVERSIONS

    def test_js_java_conversion(self):
        """Test JavaScript to Java conversion is valid."""
        assert (Language.JAVASCRIPT, Language.JAVA) in VALID_CONVERSIONS
        assert (Language.JAVA, Language.JAVASCRIPT) in VALID_CONVERSIONS

    def test_ts_java_conversion(self):
        """Test TypeScript to Java conversion is valid."""
        assert (Language.TYPESCRIPT, Language.JAVA) in VALID_CONVERSIONS
        assert (Language.JAVA, Language.TYPESCRIPT) in VALID_CONVERSIONS

    def test_python_java_conversion(self):
        """Test Python to Java conversion is valid."""
        assert (Language.PYTHON, Language.JAVA) in VALID_CONVERSIONS
        assert (Language.JAVA, Language.PYTHON) in VALID_CONVERSIONS


class TestConversionRequest:
    """Tests for ConversionRequest model."""

    def test_valid_request(self, sample_python_code):
        """Test creating a valid conversion request."""
        request = ConversionRequest(
            source_code=sample_python_code,
            source_language=Language.PYTHON,
            target_language=Language.JAVASCRIPT,
            model="codellama"
        )
        
        assert request.source_code == sample_python_code
        assert request.source_language == Language.PYTHON
        assert request.target_language == Language.JAVASCRIPT
        assert request.model == "codellama"

    def test_invalid_conversion_pair(self, sample_python_code):
        """Test that invalid conversion pair raises error."""
        with pytest.raises(ValueError):
            ConversionRequest(
                source_code=sample_python_code,
                source_language=Language.PYTHON,
                target_language=Language.PYTHON,
                model="codellama"
            )

    def test_default_model(self, sample_python_code):
        """Test default model value."""
        request = ConversionRequest(
            source_code=sample_python_code,
            source_language=Language.PYTHON,
            target_language=Language.JAVASCRIPT
        )
        
        assert request.model == "codellama"


class TestConversionResult:
    """Tests for ConversionResult model."""

    def test_successful_result(self, successful_conversion_result):
        """Test successful conversion result."""
        assert successful_conversion_result.success is True
        assert successful_conversion_result.converted_code is not None
        assert successful_conversion_result.error_message is None
        assert successful_conversion_result.syntax_verified is True

    def test_failed_result(self, failed_conversion_result):
        """Test failed conversion result."""
        assert failed_conversion_result.success is False
        assert failed_conversion_result.converted_code is None
        assert failed_conversion_result.error_message is not None

    def test_default_values(self, sample_python_code):
        """Test default values for ConversionResult."""
        result = ConversionResult(
            success=True,
            converted_code="test",
            original_code=sample_python_code,
            source_language=Language.PYTHON,
            target_language=Language.JAVASCRIPT,
            model="codellama"
        )
        
        assert result.syntax_verified is False
        assert result.syntax_warnings == []


class TestModelInfo:
    """Tests for ModelInfo model."""

    def test_model_info_creation(self):
        """Test creating ModelInfo."""
        info = ModelInfo(
            name="codellama",
            size="4GB",
            modified_at="2024-01-01"
        )
        
        assert info.name == "codellama"
        assert info.size == "4GB"
        assert info.modified_at == "2024-01-01"

    def test_model_info_optional_fields(self):
        """Test ModelInfo with optional fields."""
        info = ModelInfo(name="test-model")
        
        assert info.name == "test-model"
        assert info.size is None
        assert info.modified_at is None


class TestFileConversionResult:
    """Tests for FileConversionResult model."""

    def test_successful_file_conversion(self):
        """Test successful file conversion result."""
        result = FileConversionResult(
            input_path="/input/file.py",
            output_path="/output/file.js",
            success=True
        )
        
        assert result.input_path == "/input/file.py"
        assert result.output_path == "/output/file.js"
        assert result.success is True
        assert result.error_message is None

    def test_failed_file_conversion(self):
        """Test failed file conversion result."""
        result = FileConversionResult(
            input_path="/input/file.py",
            success=False,
            error_message="Connection failed"
        )
        
        assert result.success is False
        assert result.error_message == "Connection failed"