"""Tests for code analyzers."""

import tempfile
from pathlib import Path


from src.auto_readme.analyzers import (
    PythonAnalyzer,
    JavaScriptAnalyzer,
    GoAnalyzer,
    RustAnalyzer,
    CodeAnalyzerFactory,
)


class TestPythonAnalyzer:
    """Tests for PythonAnalyzer."""

    def test_can_analyze_py_file(self):
        """Test that analyzer recognizes Python files."""
        analyzer = PythonAnalyzer()
        with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode="w") as f:
            f.write("def hello():\n    pass")
            f.flush()
            assert analyzer.can_analyze(Path(f.name))
            Path(f.name).unlink()

    def test_can_analyze_pyi_file(self):
        """Test that analyzer recognizes .pyi stub files."""
        analyzer = PythonAnalyzer()
        with tempfile.NamedTemporaryFile(suffix=".pyi", delete=False, mode="w") as f:
            f.write("def hello() -> None: ...")
            f.flush()
            assert analyzer.can_analyze(Path(f.name))
            Path(f.name).unlink()

    def test_analyze_simple_function(self):
        """Test analyzing a simple function."""
        with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode="w") as f:
            f.write('''"""Module docstring."""

def hello():
    """Say hello."""
    print("Hello, World!")

class Calculator:
    """A calculator class."""

    def add(self, a, b):
        """Add two numbers."""
        return a + b
''')
            f.flush()
            file_path = Path(f.name)
            analyzer = PythonAnalyzer()
            result = analyzer.analyze(file_path)

            assert len(result["functions"]) == 2  # hello and add
            assert len(result["classes"]) == 1

            hello_func = next((f for f in result["functions"] if f.name == "hello"), None)
            assert hello_func is not None
            assert hello_func.docstring == "Say hello."
            assert hello_func.parameters == []

            calc_class = result["classes"][0]
            assert calc_class.name == "Calculator"
            assert calc_class.docstring == "A calculator class."

            Path(f.name).unlink()

    def test_analyze_with_parameters(self):
        """Test analyzing functions with parameters."""
        with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode="w") as f:
            f.write('''def greet(name, greeting="Hello"):
    """Greet someone."""
    return f"{greeting}, {name}!"

def add_numbers(a: int, b: int) -> int:
    """Add two integers."""
    return a + b
''')
            f.flush()
            file_path = Path(f.name)
            analyzer = PythonAnalyzer()
            result = analyzer.analyze(file_path)

            greet_func = next((f for f in result["functions"] if f.name == "greet"), None)
            assert greet_func is not None
            assert "name" in greet_func.parameters
            assert "greeting" in greet_func.parameters

            Path(f.name).unlink()


class TestJavaScriptAnalyzer:
    """Tests for JavaScriptAnalyzer."""

    def test_can_analyze_js_file(self):
        """Test that analyzer recognizes JavaScript files."""
        analyzer = JavaScriptAnalyzer()
        with tempfile.NamedTemporaryFile(suffix=".js", delete=False, mode="w") as f:
            f.write("function hello() { return 'hello'; }")
            f.flush()
            assert analyzer.can_analyze(Path(f.name))
            Path(f.name).unlink()

    def test_can_analyze_ts_file(self):
        """Test that analyzer recognizes TypeScript files."""
        analyzer = JavaScriptAnalyzer()
        with tempfile.NamedTemporaryFile(suffix=".ts", delete=False, mode="w") as f:
            f.write("const hello = (): string => 'hello';")
            f.flush()
            assert analyzer.can_analyze(Path(f.name))
            Path(f.name).unlink()

    def test_analyze_simple_function(self):
        """Test analyzing a simple JavaScript function."""
        with tempfile.NamedTemporaryFile(suffix=".js", delete=False, mode="w") as f:
            f.write('''function hello(name) {
    return "Hello, " + name + "!";
}

class Calculator {
    add(a, b) {
        return a + b;
    }
}

module.exports = { hello, Calculator };
''')
            f.flush()
            file_path = Path(f.name)
            analyzer = JavaScriptAnalyzer()
            result = analyzer.analyze(file_path)

            assert len(result["functions"]) >= 1

            hello_func = next((f for f in result["functions"] if f.name == "hello"), None)
            assert hello_func is not None

            Path(f.name).unlink()


class TestGoAnalyzer:
    """Tests for GoAnalyzer."""

    def test_can_analyze_go_file(self):
        """Test that analyzer recognizes Go files."""
        analyzer = GoAnalyzer()
        with tempfile.NamedTemporaryFile(suffix=".go", delete=False, mode="w") as f:
            f.write("package main\n\nfunc hello() string { return 'hello' }")
            f.flush()
            assert analyzer.can_analyze(Path(f.name))
            Path(f.name).unlink()

    def test_analyze_simple_function(self):
        """Test analyzing a simple Go function."""
        with tempfile.NamedTemporaryFile(suffix=".go", delete=False, mode="w") as f:
            f.write('''package main

import "fmt"

func hello(name string) string {
    return "Hello, " + name
}

type Calculator struct{}

func (c *Calculator) Add(a, b int) int {
    return a + b
}
''')
            f.flush()
            file_path = Path(f.name)
            analyzer = GoAnalyzer()
            result = analyzer.analyze(file_path)

            hello_func = next((f for f in result["functions"] if f.name == "hello"), None)
            assert hello_func is not None
            assert hello_func.return_type is not None or "string" in str(hello_func.return_type)

            Path(f.name).unlink()


class TestRustAnalyzer:
    """Tests for RustAnalyzer."""

    def test_can_analyze_rs_file(self):
        """Test that analyzer recognizes Rust files."""
        analyzer = RustAnalyzer()
        with tempfile.NamedTemporaryFile(suffix=".rs", delete=False, mode="w") as f:
            f.write("fn hello() -> String { String::from('hello') }")
            f.flush()
            assert analyzer.can_analyze(Path(f.name))
            Path(f.name).unlink()

    def test_analyze_simple_function(self):
        """Test analyzing a simple Rust function."""
        with tempfile.NamedTemporaryFile(suffix=".rs", delete=False, mode="w") as f:
            f.write('''fn hello(name: &str) -> String {
    format!("Hello, {}", name)
}

pub struct Calculator;

impl Calculator {
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }
}
''')
            f.flush()
            file_path = Path(f.name)
            analyzer = RustAnalyzer()
            result = analyzer.analyze(file_path)

            hello_func = next((f for f in result["functions"] if f.name == "hello"), None)
            assert hello_func is not None
            assert "name" in hello_func.parameters
            assert hello_func.visibility == "private"

            Path(f.name).unlink()


class TestCodeAnalyzerFactory:
    """Tests for CodeAnalyzerFactory."""

    def test_get_analyzer_python(self):
        """Test getting analyzer for Python file."""
        analyzer = CodeAnalyzerFactory.get_analyzer(Path("main.py"))
        assert isinstance(analyzer, PythonAnalyzer)

    def test_get_analyzer_js(self):
        """Test getting analyzer for JavaScript file."""
        analyzer = CodeAnalyzerFactory.get_analyzer(Path("index.js"))
        assert isinstance(analyzer, JavaScriptAnalyzer)

    def test_get_analyzer_go(self):
        """Test getting analyzer for Go file."""
        analyzer = CodeAnalyzerFactory.get_analyzer(Path("main.go"))
        assert isinstance(analyzer, GoAnalyzer)

    def test_get_analyzer_rust(self):
        """Test getting analyzer for Rust file."""
        analyzer = CodeAnalyzerFactory.get_analyzer(Path("main.rs"))
        assert isinstance(analyzer, RustAnalyzer)

    def test_can_analyze(self):
        """Test can_analyze returns correct results."""
        assert CodeAnalyzerFactory.can_analyze(Path("main.py"))
        assert CodeAnalyzerFactory.can_analyze(Path("index.js"))
        assert CodeAnalyzerFactory.can_analyze(Path("main.go"))
        assert CodeAnalyzerFactory.can_analyze(Path("main.rs"))
        assert not CodeAnalyzerFactory.can_analyze(Path("random.txt"))