"""Unit tests for analyzers."""

import tempfile
from pathlib import Path

import pytest
from vibeguard.analyzers.languages.python import PythonAnalyzer
from vibeguard.analyzers.languages.javascript import JavaScriptAnalyzer
from vibeguard.analyzers.languages.typescript import TypeScriptAnalyzer
from vibeguard.analyzers.languages.go import GoAnalyzer
from vibeguard.analyzers.languages.rust import RustAnalyzer
from vibeguard.analyzers.factory import AnalyzerFactory


class TestPythonAnalyzer:
    """Tests for Python analyzer."""

    def setup_method(self):
        """Set up test fixtures."""
        self.analyzer = PythonAnalyzer()

    def test_parse_valid_python(self):
        """Test parsing valid Python code."""
        code = """
def hello():
    return "world"
"""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
            f.write(code)
            f.flush()

        try:
            tree = self.analyzer.parse_file(Path(f.name))
            assert tree is not None
        finally:
            Path(f.name).unlink()

    def test_parse_invalid_python(self):
        """Test parsing invalid Python code returns None."""
        code = """
def hello()
    return "world"
"""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
            f.write(code)
            f.flush()

        try:
            tree = self.analyzer.parse_file(Path(f.name))
            assert tree is None
        finally:
            Path(f.name).unlink()

    def test_get_language(self):
        """Test getting language name."""
        assert self.analyzer.get_language() == "python"

    def test_supports_extension(self):
        """Test extension checking."""
        assert self.analyzer.supports_extension(".py")
        assert self.analyzer.supports_extension(".pyi")
        assert not self.analyzer.supports_extension(".js")


class TestJavaScriptAnalyzer:
    """Tests for JavaScript analyzer."""

    def setup_method(self):
        """Set up test fixtures."""
        self.analyzer = JavaScriptAnalyzer()

    def test_parse_javascript(self):
        """Test parsing JavaScript code."""
        code = """
function hello() {
    return "world";
}
"""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".js", delete=False) as f:
            f.write(code)
            f.flush()

        try:
            content = self.analyzer.parse_file(Path(f.name))
            assert content is not None
        finally:
            Path(f.name).unlink()

    def test_get_language(self):
        """Test getting language name."""
        assert self.analyzer.get_language() == "javascript"


class TestTypeScriptAnalyzer:
    """Tests for TypeScript analyzer."""

    def setup_method(self):
        """Set up test fixtures."""
        self.analyzer = TypeScriptAnalyzer()

    def test_parse_typescript(self):
        """Test parsing TypeScript code."""
        code = """
function hello(): string {
    return "world";
}
"""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".ts", delete=False) as f:
            f.write(code)
            f.flush()

        try:
            content = self.analyzer.parse_file(Path(f.name))
            assert content is not None
        finally:
            Path(f.name).unlink()

    def test_get_language(self):
        """Test getting language name."""
        assert self.analyzer.get_language() == "typescript"


class TestGoAnalyzer:
    """Tests for Go analyzer."""

    def setup_method(self):
        """Set up test fixtures."""
        self.analyzer = GoAnalyzer()

    def test_parse_go(self):
        """Test parsing Go code."""
        code = """
package main

func hello() string {
    return "world"
}
"""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".go", delete=False) as f:
            f.write(code)
            f.flush()

        try:
            content = self.analyzer.parse_file(Path(f.name))
            assert content is not None
        finally:
            Path(f.name).unlink()

    def test_get_language(self):
        """Test getting language name."""
        assert self.analyzer.get_language() == "go"


class TestRustAnalyzer:
    """Tests for Rust analyzer."""

    def setup_method(self):
        """Set up test fixtures."""
        self.analyzer = RustAnalyzer()

    def test_parse_rust(self):
        """Test parsing Rust code."""
        code = """
fn hello() -> &'static str {
    return "world";
}
"""
        with tempfile.NamedTemporaryFile(mode="w", suffix=".rs", delete=False) as f:
            f.write(code)
            f.flush()

        try:
            content = self.analyzer.parse_file(Path(f.name))
            assert content is not None
        finally:
            Path(f.name).unlink()

    def test_get_language(self):
        """Test getting language name."""
        assert self.analyzer.get_language() == "rust"


class TestAnalyzerFactory:
    """Tests for analyzer factory."""

    def test_get_python_analyzer(self):
        """Test getting Python analyzer."""
        analyzer = AnalyzerFactory.get_analyzer(Path("test.py"))
        assert analyzer is not None
        assert analyzer.get_language() == "python"

    def test_get_javascript_analyzer(self):
        """Test getting JavaScript analyzer."""
        analyzer = AnalyzerFactory.get_analyzer(Path("test.js"))
        assert analyzer is not None
        assert analyzer.get_language() == "javascript"

    def test_get_typescript_analyzer(self):
        """Test getting TypeScript analyzer."""
        analyzer = AnalyzerFactory.get_analyzer(Path("test.ts"))
        assert analyzer is not None
        assert analyzer.get_language() == "typescript"

    def test_get_go_analyzer(self):
        """Test getting Go analyzer."""
        analyzer = AnalyzerFactory.get_analyzer(Path("test.go"))
        assert analyzer is not None
        assert analyzer.get_language() == "go"

    def test_get_rust_analyzer(self):
        """Test getting Rust analyzer."""
        analyzer = AnalyzerFactory.get_analyzer(Path("test.rs"))
        assert analyzer is not None
        assert analyzer.get_language() == "rust"

    def test_get_unsupported_file(self):
        """Test getting analyzer for unsupported file."""
        analyzer = AnalyzerFactory.get_analyzer(Path("test.txt"))
        assert analyzer is None

    def test_get_supported_languages(self):
        """Test getting supported languages."""
        languages = AnalyzerFactory.get_supported_languages()
        assert "python" in languages
        assert "javascript" in languages
        assert "typescript" in languages
        assert "go" in languages
        assert "rust" in languages

    def test_get_supported_extensions(self):
        """Test getting supported extensions."""
        extensions = AnalyzerFactory.get_supported_extensions()
        assert ".py" in extensions
        assert ".js" in extensions
        assert ".ts" in extensions
        assert ".go" in extensions
        assert ".rs" in extensions