// Step 372: Lisp Annotation Mapping (12 tests)

#include <cassert>
#include <iostream>
#include <string>
#include <vector>
#include "AnnotationInference.h"
#include "MemoryStrategyInference.h"
#include "CrossLanguageProjector.h"
#include "ast/PythonGenerator.h"
#include "ast/CppGenerator.h"
#include "ast/ClassDeclaration.h"

static bool hasInference(const std::vector<AnnotationInference::InferredAnnotation>& inferred,
                         const std::string& annotationType,
                         const std::string& value) {
    for (const auto& a : inferred) {
        if (a.annotationType == annotationType && a.value == value) return true;
    }
    return false;
}

static bool hasMemorySuggestion(const std::vector<MemoryStrategyInference::Suggestion>& suggestions,
                                const std::string& annotationType,
                                const std::string& strategy) {
    for (const auto& s : suggestions) {
        if (s.annotationType == annotationType && s.strategy == strategy) return true;
    }
    return false;
}

int main() {
    int passed = 0;

    // Test 1: macro -> @Meta(quoted)
    {
        Module mod("m1", "cl", "common-lisp");
        mod.addChild("statements", new MacroDefinition("mac1", "when1"));
        AnnotationInference inf;
        auto inferred = inf.inferAll(&mod);
        assert(hasInference(inferred, "MetaAnnotation", "quoted"));
        std::cout << "Test 1 PASSED: macro -> Meta(quoted)\n";
        passed++;
    }

    // Test 2: dynamic variable -> @Binding(dynamic)
    {
        Module mod("m1", "cl", "common-lisp");
        mod.addChild("variables", new Variable("v1", "*runtime-mode*"));
        AnnotationInference inf;
        auto inferred = inf.inferAll(&mod);
        assert(hasInference(inferred, "BindingAnnotation", "dynamic"));
        std::cout << "Test 2 PASSED: dynamic variable -> Binding(dynamic)\n";
        passed++;
    }

    // Test 3: values form -> @Contract(multiple-values)
    {
        Module mod("m1", "cl", "common-lisp");
        auto* fn = new Function("f1", "pair");
        auto* valuesCall = new FunctionCall();
        valuesCall->id = "c1";
        valuesCall->functionName = "values";
        valuesCall->addChild("arguments", new IntegerLiteral("i1", 1));
        valuesCall->addChild("arguments", new IntegerLiteral("i2", 2));
        auto* stmt = new ExpressionStatement();
        stmt->id = "s1";
        stmt->setChild("expression", valuesCall);
        fn->addChild("body", stmt);
        mod.addChild("functions", fn);

        AnnotationInference inf;
        auto inferred = inf.inferAll(&mod);
        assert(hasInference(inferred, "ContractAnnotation", "multiple-values"));
        std::cout << "Test 3 PASSED: values -> Contract annotation\n";
        passed++;
    }

    // Test 4: tail-recursive function -> @TailCall
    {
        Module mod("m1", "cl", "common-lisp");
        auto* fn = new Function("f1", "fact");
        auto* call = new FunctionCall();
        call->id = "c1";
        call->functionName = "fact";
        auto* stmt = new ExpressionStatement();
        stmt->id = "s1";
        stmt->setChild("expression", call);
        fn->addChild("body", stmt);
        mod.addChild("functions", fn);

        AnnotationInference inf;
        auto inferred = inf.inferAll(&mod);
        assert(hasInference(inferred, "TailCallAnnotation", ""));
        std::cout << "Test 4 PASSED: tail recursion detected\n";
        passed++;
    }

    // Test 5: CLOS class -> @Visibility(public)
    {
        Module mod("m1", "cl", "common-lisp");
        mod.addChild("classes", new ClassDeclaration("c1", "point"));
        AnnotationInference inf;
        auto inferred = inf.inferAll(&mod);
        assert(hasInference(inferred, "VisibilityAnnotation", "public"));
        std::cout << "Test 5 PASSED: CLOS class -> Visibility(public)\n";
        passed++;
    }

    // Test 6: optimize declaration -> @Policy(perf=critical, style=literal)
    {
        Module mod("m1", "cl", "common-lisp");
        auto* fn = new Function("f1", "hot");
        auto* optimize = new FunctionCall();
        optimize->id = "c2";
        optimize->functionName = "optimize";
        auto* decl = new FunctionCall();
        decl->id = "c1";
        decl->functionName = "declare";
        decl->addChild("arguments", optimize);
        auto* stmt = new ExpressionStatement();
        stmt->id = "s1";
        stmt->setChild("expression", decl);
        fn->addChild("body", stmt);
        mod.addChild("functions", fn);

        AnnotationInference inf;
        auto inferred = inf.inferAll(&mod);
        assert(hasInference(inferred, "PolicyAnnotation", "critical"));
        assert(hasInference(inferred, "PolicyAnnotation", "literal"));
        std::cout << "Test 6 PASSED: optimize -> Policy mapping\n";
        passed++;
    }

    // Test 7: CL memory defaults -> GC
    {
        Module mod("m1", "cl", "common-lisp");
        MemoryStrategyInference mem;
        auto suggestions = mem.inferAnnotations(&mod);
        assert(hasMemorySuggestion(suggestions, "ReclaimAnnotation", "Tracing"));
        assert(hasMemorySuggestion(suggestions, "OwnerAnnotation", "Shared_GC"));
        std::cout << "Test 7 PASSED: CL memory defaults (GC)\n";
        passed++;
    }

    // Test 8: confidence values are bounded and include strong signal
    {
        Module mod("m1", "cl", "common-lisp");
        mod.addChild("statements", new MacroDefinition("mac1", "m"));
        mod.addChild("variables", new Variable("v1", "*x*"));
        AnnotationInference inf;
        auto inferred = inf.inferAll(&mod);
        bool strong = false;
        for (const auto& a : inferred) {
            assert(a.confidence >= 0.0 && a.confidence <= 1.0);
            if (a.confidence >= 0.90) strong = true;
        }
        assert(strong);
        std::cout << "Test 8 PASSED: confidence bounds\n";
        passed++;
    }

    // Test 9: CL @Binding(dynamic) -> Python projection preserves annotation
    {
        Module mod("m1", "cl", "common-lisp");
        auto* fn = new Function("f1", "f");
        auto* b = new BindingAnnotation();
        b->id = "a1";
        b->time = "dynamic";
        fn->addChild("annotations", b);
        mod.addChild("functions", fn);

        CrossLanguageProjector projector;
        auto pyMod = projector.project(&mod, "python");
        PythonGenerator gen;
        auto out = gen.generate(pyMod.get());
        assert(projector.annotationsPreserved(&mod, pyMod.get()));
        assert(out.find("def f(") != std::string::npos);
        std::cout << "Test 9 PASSED: binding(dynamic) preserved to Python projection\n";
        passed++;
    }

    // Test 10: CL @Binding(dynamic) -> C++ projection preserves annotation
    {
        Module mod("m1", "cl", "common-lisp");
        auto* fn = new Function("f1", "f");
        auto* b = new BindingAnnotation();
        b->id = "a1";
        b->time = "dynamic";
        fn->addChild("annotations", b);
        mod.addChild("functions", fn);

        CrossLanguageProjector projector;
        auto cppMod = projector.project(&mod, "cpp");
        CppGenerator gen;
        auto out = gen.generate(cppMod.get());
        assert(projector.annotationsPreserved(&mod, cppMod.get()));
        assert(out.find("f(") != std::string::npos);
        std::cout << "Test 10 PASSED: binding(dynamic) preserved to C++ projection\n";
        passed++;
    }

    // Test 11: (declare (type ...)) -> Complexity(declared-type)
    {
        Module mod("m1", "cl", "common-lisp");
        auto* fn = new Function("f1", "typed");
        auto* typeCall = new FunctionCall();
        typeCall->id = "c2";
        typeCall->functionName = "type";
        typeCall->addChild("arguments", new VariableReference("r1", "fixnum"));
        auto* decl = new FunctionCall();
        decl->id = "c1";
        decl->functionName = "declare";
        decl->addChild("arguments", typeCall);
        auto* stmt = new ExpressionStatement();
        stmt->id = "s1";
        stmt->setChild("expression", decl);
        fn->addChild("body", stmt);
        mod.addChild("functions", fn);

        AnnotationInference inf;
        auto inferred = inf.inferAll(&mod);
        assert(hasInference(inferred, "ComplexityAnnotation", "declared-type"));
        std::cout << "Test 11 PASSED: declare(type) -> Complexity mapping\n";
        passed++;
    }

    // Test 12: CLOS method -> synthetic method-combination hint
    {
        Module mod("m1", "cl", "common-lisp");
        mod.addChild("functions", new MethodDeclaration("m1", "area"));
        AnnotationInference inf;
        auto inferred = inf.inferAll(&mod);
        assert(hasInference(inferred, "SyntheticAnnotation", "clos-method"));
        std::cout << "Test 12 PASSED: CLOS method -> synthetic hint\n";
        passed++;
    }

    std::cout << "\nResults: " << passed << "/12\n";
    assert(passed == 12);
    return 0;
}