from unittest.mock import MagicMock

import pytest

from codegraphcontext_cpp._parser import CppTreeSitterParser

from codegraphcontext.utils.tree_sitter_manager import get_tree_sitter_manager

@pytest.fixture(scope="module")

def cpp_parser():

manager = get_tree_sitter_manager()

if not manager.is_language_available("cpp"):

pytest.skip("C++ tree-sitter grammar is not available in this environment")

wrapper = MagicMock()

wrapper.language_name = "cpp"

wrapper.language = manager.get_language_safe("cpp")

wrapper.parser = manager.create_parser("cpp")

return CppTreeSitterParser(wrapper)

# --- Bugfix: _find_enums NameError ---

def test_enum_parsing(cpp_parser, temp_test_dir):

code = """

enum Color { RED, GREEN, BLUE };

enum class Status { OK = 0, ERROR = 1 };

"""

f = temp_test_dir / "enums.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

enum_names = [e["name"] for e in result.get("enums", [])]

assert "Color" in enum_names

assert "Status" in enum_names

def test_file_with_enums_and_classes(cpp_parser, temp_test_dir):

"""Ensure files containing both enums and classes parse without errors."""

code = """

enum DataType { INT = 0, VARCHAR = 1 };

class Foo {

public:

void bar() {}

};

"""

f = temp_test_dir / "mixed.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

assert any(c["name"] == "Foo" for c in result["classes"])

assert any(e["name"] == "DataType" for e in result.get("enums", []))

# --- Fix 1: Inheritance / base class extraction ---

def test_single_public_inheritance(cpp_parser, temp_test_dir):

code = """

class Base {

public:

virtual void execute() {}

};

class Derived : public Base {

public:

void execute() override {}

};

"""

f = temp_test_dir / "inherit_single.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

classes = {c["name"]: c for c in result["classes"]}

assert "Base" in classes

assert "Derived" in classes

assert classes["Base"]["bases"] == []

assert classes["Derived"]["bases"] == ["Base"]

def test_multiple_inheritance(cpp_parser, temp_test_dir):

code = """

class A {};

class B {};

class C : public A, private B {};

"""

f = temp_test_dir / "inherit_multi.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

classes = {c["name"]: c for c in result["classes"]}

assert classes["C"]["bases"] == ["A", "B"]

def test_virtual_inheritance(cpp_parser, temp_test_dir):

code = """

class Base {};

class Derived : virtual public Base {};

"""

f = temp_test_dir / "inherit_virtual.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

classes = {c["name"]: c for c in result["classes"]}

assert classes["Derived"]["bases"] == ["Base"]

def test_template_base_class(cpp_parser, temp_test_dir):

code = """

template<typename T>

class Container {};

class IntContainer : public Container<int> {};

"""

f = temp_test_dir / "inherit_template.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

classes = {c["name"]: c for c in result["classes"]}

# Template args should be stripped for graph matching

assert "Container" in classes["IntContainer"]["bases"]

def test_qualified_base_class(cpp_parser, temp_test_dir):

code = """

namespace ns {

class Base {};

}

class Derived : public ns::Base {};

"""

f = temp_test_dir / "inherit_qualified.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

classes = {c["name"]: c for c in result["classes"]}

assert len(classes["Derived"]["bases"]) == 1

# Should capture the qualified name

assert "Base" in classes["Derived"]["bases"][0]

# --- Fix 2: Qualified function definitions (ClassName::method in .cpp files) ---

def test_qualified_method_definition(cpp_parser, temp_test_dir):

code = """

void QueueElement::execute() {

return;

}

void QueueElement::setStatus(int status) {

this->status = status;

}

void free_function() {

return;

}

"""

f = temp_test_dir / "methods.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

func_names = [fn["name"] for fn in result["functions"]]

assert "execute" in func_names

assert "setStatus" in func_names

assert "free_function" in func_names

# Verify class_context is set for qualified methods

execute_fn = next(fn for fn in result["functions"] if fn["name"] == "execute")

assert execute_fn.get("class_context") == "QueueElement"

set_status_fn = next(fn for fn in result["functions"] if fn["name"] == "setStatus")

assert set_status_fn.get("class_context") == "QueueElement"

free_fn = next(fn for fn in result["functions"] if fn["name"] == "free_function")

assert free_fn.get("class_context") is None

def test_nested_qualified_method(cpp_parser, temp_test_dir):

code = """

void Namespace::Class::method() {

return;

}

"""

f = temp_test_dir / "nested_method.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

func_names = [fn["name"] for fn in result["functions"]]

assert "method" in func_names

method_fn = next(fn for fn in result["functions"] if fn["name"] == "method")

assert method_fn.get("class_context") == "Namespace::Class"

# --- Fix 3: Call expression matching (-> and :: calls) ---

def test_arrow_method_calls(cpp_parser, temp_test_dir):

code = """

void doWork() {

obj->execute();

ptr->setStatus(1);

}

"""

f = temp_test_dir / "arrow_calls.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

call_names = [c["name"] for c in result["function_calls"]]

assert "execute" in call_names

assert "setStatus" in call_names

def test_scoped_calls(cpp_parser, temp_test_dir):

code = """

void doWork() {

std::move(x);

QueueElement::setStatus(1);

}

"""

f = temp_test_dir / "scoped_calls.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

call_names = [c["name"] for c in result["function_calls"]]

assert "move" in call_names

assert "setStatus" in call_names

# Check inferred_obj_type for scoped calls

move_call = next(c for c in result["function_calls"] if c["name"] == "move")

assert move_call["inferred_obj_type"] == "std"

status_call = next(c for c in result["function_calls"] if c["name"] == "setStatus")

assert status_call["inferred_obj_type"] == "QueueElement"

def test_this_pointer_calls(cpp_parser, temp_test_dir):

code = """

void MyClass::doWork() {

this->execute();

this->setStatus(1);

}

"""

f = temp_test_dir / "this_calls.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

call_names = [c["name"] for c in result["function_calls"]]

assert "execute" in call_names

assert "setStatus" in call_names

for call in result["function_calls"]:

assert call["inferred_obj_type"] == "this"

def test_direct_function_calls(cpp_parser, temp_test_dir):

code = """

void doWork() {

printf("hello");

free_function();

}

"""

f = temp_test_dir / "direct_calls.cpp"

f.write_text(code)

result = cpp_parser.parse(f)

call_names = [c["name"] for c in result["function_calls"]]

assert "printf" in call_names

assert "free_function" in call_names

# --- Integration: realistic C++ header with inheritance + methods ---

def test_realistic_header(cpp_parser, temp_test_dir):

code = """

class QueueElement_Manuell {

public:

virtual std::string getRequestInformation() = 0;

};

class QueueElement : public QueueElement_Manuell {

public:

virtual int execute() { return 0; }

virtual std::string getMonitorInfo() = 0;

};

class QueueElement_Dialer : public QueueElement {

public:

virtual int execute() { return 0; }

};

class QueueElement_Dialer_Export : public QueueElement_Dialer {

public:

virtual int execute();

virtual std::string getMonitorInfo();

};

class QueueElement_Dialer_Export_File : public QueueElement_Dialer_Export {

public:

QueueElement_Dialer_Export_File() {}

};

class QueueElement_Dialer_Export_Axa : public QueueElement_Dialer_Export {

public:

virtual int execute();

virtual std::string getMonitorInfo();

};

"""

f = temp_test_dir / "realistic.h"

f.write_text(code)

result = cpp_parser.parse(f)

classes = {c["name"]: c for c in result["classes"]}

assert classes["QueueElement_Manuell"]["bases"] == []

assert classes["QueueElement"]["bases"] == ["QueueElement_Manuell"]

assert classes["QueueElement_Dialer"]["bases"] == ["QueueElement"]

assert classes["QueueElement_Dialer_Export"]["bases"] == ["QueueElement_Dialer"]

assert classes["QueueElement_Dialer_Export_File"]["bases"] == ["QueueElement_Dialer_Export"]

assert classes["QueueElement_Dialer_Export_Axa"]["bases"] == ["QueueElement_Dialer_Export"]