"""Tests for language analyzers and parsers."""

import pytest
from pathlib import Path

from src.analyzers import PythonParser, JavaScriptParser, TypeScriptParser, ParserFactory


class TestPythonParser:
    """Tests for Python parser."""

    def setup_method(self):
        self.parser = PythonParser()

    def test_parses_simple_function(self):
        code = """
def hello():
    print("Hello")
"""
        tree = self.parser.parse(code)
        assert tree is not None
        assert tree.root_node is not None

    def test_extracts_functions(self):
        code = """
def foo():
    pass

def bar():
    pass
"""
        tree = self.parser.parse(code)
        functions = self.parser.get_functions(tree.root_node)
        assert len(functions) == 2

    def test_extracts_calls(self):
        code = """
foo()
bar()
"""
        tree = self.parser.parse(code)
        calls = self.parser.get_calls(tree.root_node)
        assert len(calls) == 2

    def test_extracts_strings(self):
        code = '''
name = "hello"
message = 'world'
'''
        tree = self.parser.parse(code)
        strings = self.parser.get_strings(tree.root_node)
        assert len(strings) >= 2

    def test_language_name(self):
        assert self.parser.language_name == "python"


class TestJavaScriptParser:
    """Tests for JavaScript parser."""

    def setup_method(self):
        self.parser = JavaScriptParser()

    def test_parses_simple_function(self):
        code = """
function hello() {
    console.log("Hello");
}
"""
        tree = self.parser.parse(code)
        assert tree is not None
        assert tree.root_node is not None

    def test_extracts_functions(self):
        code = """
function foo() {}
function bar() {}
"""
        tree = self.parser.parse(code)
        functions = self.parser.get_functions(tree.root_node)
        assert len(functions) == 2

    def test_extracts_calls(self):
        code = """
foo();
bar();
"""
        tree = self.parser.parse(code)
        calls = self.parser.get_calls(tree.root_node)
        assert len(calls) == 2

    def test_language_name(self):
        assert self.parser.language_name == "javascript"


class TestTypeScriptParser:
    """Tests for TypeScript parser."""

    def setup_method(self):
        self.parser = TypeScriptParser()

    def test_parses_simple_function(self):
        code = """
function hello(): void {
    console.log("Hello");
}
"""
        tree = self.parser.parse(code)
        assert tree is not None
        assert tree.root_node is not None

    def test_extracts_functions(self):
        code = """
function foo(): void {}
function bar(): void {}
"""
        tree = self.parser.parse(code)
        functions = self.parser.get_functions(tree.root_node)
        assert len(functions) == 2

    def test_extracts_calls(self):
        code = """
foo();
bar();
"""
        tree = self.parser.parse(code)
        calls = self.parser.get_calls(tree.root_node)
        assert len(calls) == 2

    def test_language_name(self):
        assert self.parser.language_name == "typescript"


class TestParserFactory:
    """Tests for parser factory."""

    def test_get_python_parser(self):
        parser = ParserFactory.get_parser("python")
        assert parser is not None
        assert isinstance(parser, PythonParser)

    def test_get_javascript_parser(self):
        parser = ParserFactory.get_parser("javascript")
        assert parser is not None
        assert isinstance(parser, JavaScriptParser)

    def test_get_typescript_parser(self):
        parser = ParserFactory.get_parser("typescript")
        assert parser is not None
        assert isinstance(parser, TypeScriptParser)

    def test_get_unknown_parser(self):
        parser = ParserFactory.get_parser("unknown")
        assert parser is None

    def test_supported_languages(self):
        languages = ParserFactory.supported_languages()
        assert "python" in languages
        assert "javascript" in languages
        assert "typescript" in languages