from pathlib import Path
from src.parsers.base import BaseParser, Entity, EntityType, ParserResult
from src.parsers.python import PythonParser
from src.parsers.javascript import JavaScriptParser
from src.parsers.go import GoParser
from src.parsers.rust import RustParser


class TestBaseParser:
    def test_entity_creation(self):
        entity = Entity(
            name="test_func",
            entity_type=EntityType.FUNCTION,
            file_path=Path("/test/file.py"),
            start_line=1,
            end_line=10,
            code="def test_func(): pass",
        )
        assert entity.name == "test_func"
        assert entity.entity_type == EntityType.FUNCTION
        assert entity.start_line == 1
        assert entity.end_line == 10

    def test_parser_result(self):
        result = ParserResult(
            file_path=Path("/test/file.py"),
            language="python",
        )
        assert result.file_path == Path("/test/file.py")
        assert result.language == "python"
        assert result.entities == []
        assert result.imports == []


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

    def test_parse_simple_function(self):
        code = """
def hello():
    print("Hello, World!")
"""
        result = self.parser.parse(Path("/test.py"), code)
        assert result.language == "python"
        assert len(result.entities) >= 1

    def test_parse_class_with_methods(self):
        code = """
class MyClass:
    def method1(self):
        pass

    def method2(self):
        pass
"""
        result = self.parser.parse(Path("/test.py"), code)
        assert result.language == "python"
        class_entities = [e for e in result.entities if e.entity_type == EntityType.CLASS]
        assert len(class_entities) == 1

    def test_extract_imports(self):
        code = """
import os
import sys
from pathlib import Path
"""
        result = self.parser.parse(Path("/test.py"), code)
        assert "os" in result.imports
        assert "sys" in result.imports

    def test_can_parse_py_file(self):
        assert self.parser.can_parse(Path("/test.py"))
        assert self.parser.can_parse(Path("/test.pyi"))
        assert not self.parser.can_parse(Path("/test.js"))


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

    def test_parse_function(self):
        code = """
function hello() {
    console.log("Hello");
}
"""
        result = self.parser.parse(Path("/test.js"), code)
        assert result.language == "javascript"
        assert len(result.entities) >= 1

    def test_parse_arrow_function(self):
        code = """
const add = (a, b) => a + b;
"""
        result = self.parser.parse(Path("/test.js"), code)
        assert result.language == "javascript"

    def test_parse_class(self):
        code = """
class MyClass {
    constructor() {}

    method1() {}
}
"""
        result = self.parser.parse(Path("/test.js"), code)
        class_entities = [e for e in result.entities if e.entity_type == EntityType.CLASS]
        assert len(class_entities) == 1

    def test_can_parse_js_file(self):
        assert self.parser.can_parse(Path("/test.js"))
        assert self.parser.can_parse(Path("/test.jsx"))
        assert not self.parser.can_parse(Path("/test.py"))


class TestGoParser:
    def setup_method(self):
        self.parser = GoParser()

    def test_parse_function(self):
        code = """
func hello() {
    fmt.Println("Hello")
}
"""
        result = self.parser.parse(Path("/test.go"), code)
        assert result.language == "go"
        assert len(result.entities) >= 1

    def test_parse_struct(self):
        code = """
type Person struct {
    Name string
    Age  int
}
"""
        result = self.parser.parse(Path("/test.go"), code)
        assert result.language == "go"

    def test_can_parse_go_file(self):
        assert self.parser.can_parse(Path("/test.go"))
        assert not self.parser.can_parse(Path("/test.py"))


class TestRustParser:
    def setup_method(self):
        self.parser = RustParser()

    def test_parse_function(self):
        code = """
fn hello() {
    println!("Hello");
}
"""
        result = self.parser.parse(Path("/test.rs"), code)
        assert result.language == "rust"
        assert len(result.entities) >= 1

    def test_parse_struct(self):
        code = """
struct Person {
    name: String,
    age: u32,
}
"""
        result = self.parser.parse(Path("/test.rs"), code)
        assert result.language == "rust"

    def test_parse_trait(self):
        code = """
trait Drawable {
    fn draw(&self);
}
"""
        result = self.parser.parse(Path("/test.rs"), code)
        assert result.language == "rust"

    def test_can_parse_rs_file(self):
        assert self.parser.can_parse(Path("/test.rs"))
        assert not self.parser.can_parse(Path("/test.py"))


class TestParserFactory:
    def test_get_parser_for_python_file(self):
        parser = BaseParser.get_parser_for_file(Path("/test.py"))
        assert parser is not None
        assert isinstance(parser, PythonParser)

    def test_get_parser_for_js_file(self):
        parser = BaseParser.get_parser_for_file(Path("/test.js"))
        assert parser is not None
        assert isinstance(parser, JavaScriptParser)

    def test_get_parser_for_go_file(self):
        parser = BaseParser.get_parser_for_file(Path("/test.go"))
        assert parser is not None
        assert isinstance(parser, GoParser)

    def test_get_parser_for_rs_file(self):
        parser = BaseParser.get_parser_for_file(Path("/test.rs"))
        assert parser is not None
        assert isinstance(parser, RustParser)

    def test_get_parser_returns_none_for_unknown(self):
        parser = BaseParser.get_parser_for_file(Path("/test.xyz"))
        assert parser is None