#include "aise/engine.hpp"
#include "aise/requirements.hpp"
#include "aise/codegen.hpp"
#include "aise/testing.hpp"

#include <cassert>
#include <iostream>
#include <string>
#include <vector>

// ── 测试辅助 ──
static int test_count = 0;
static int pass_count = 0;

#define TEST(name)                                                    \
    do {                                                              \
        ++test_count;                                                 \
        std::cout << "[TEST] " << name << " ... ";                    \
    } while(0)

#define PASS()                                                        \
    do {                                                              \
        ++pass_count;                                                 \
        std::cout << "PASSED\n";                                      \
    } while(0)

#define FAIL(msg)                                                     \
    do {                                                              \
        std::cout << "FAILED: " << msg << "\n";                       \
        assert(false && msg);                                         \
    } while(0)

// ── 测试用例 ──

static void test_engine_initialization() {
    TEST("Engine initialization");
    aise::Engine engine;
    assert(engine.initialize() == true);
    assert(engine.is_running() == true);
    engine.shutdown();
    assert(engine.is_running() == false);
    PASS();
}

static void test_requirements_process() {
    TEST("RequirementsModule::processRawText");
    aise::RequirementsModule req_mod;
    std::string raw = "系统应支持需求版本管理。\n系统应提供冲突检测功能。\n";
    auto items = req_mod.processRawText(raw, "analyze");
    assert(!items.empty());
    assert(items[0].id.find("SRS-AISE_GEN") != std::string::npos);
    PASS();

    TEST("RequirementsModule::detectConflicts - no duplicates");
    auto conflicts = req_mod.detectConflicts(items);
    assert(conflicts.empty());
    PASS();

    TEST("RequirementsModule::detectConflicts - with duplicates");
    auto dup_items = items;
    dup_items.push_back(items[0]);  // 添加重复
    auto dup_conflicts = req_mod.detectConflicts(dup_items);
    assert(!dup_conflicts.empty());
    PASS();

    TEST("RequirementsModule::findById - found");
    auto* found = req_mod.findById("SRS-AISE_F-001");
    assert(found != nullptr);
    assert(found->id == "SRS-AISE_F-001");
    PASS();

    TEST("RequirementsModule::findById - not found");
    auto* not_found = req_mod.findById("NONEXIST");
    assert(not_found == nullptr);
    PASS();
}

static void test_codegen_generate() {
    TEST("CodegenModule::generate C++");
    aise::CodegenModule cg;
    auto result = cg.generate("SRS-AISE_F-001", "C++", "default");
    assert(result.success == true);
    assert(!result.generated_files.empty());
    assert(!result.trace_links.empty());
    assert(result.trace_links[0].req_id == "SRS-AISE_F-001");
    PASS();

    TEST("CodegenModule::generate Java");
    auto result_java = cg.generate("SRS-AISE_F-002", "Java", "default");
    assert(result_java.success == true);
    PASS();

    TEST("CodegenModule::generate unsupported language");
    auto result_bad = cg.generate("SRS-AISE_F-001", "Python", "default");
    assert(result_bad.success == false);
    PASS();

    TEST("CodegenModule::getTraceLinks");
    auto links = cg.getTraceLinks("SRS-AISE_F-001");
    assert(!links.empty());
    PASS();
}

static void test_testing_module() {
    TEST("TestingModule::generateTestCases");
    aise::TestingModule tm;
    auto cases = tm.generateTestCases("SRS-AISE_F-003", "int main(){}");
    assert(cases.size() >= 3);  // normal, boundary, exception
    PASS();

    TEST("TestingModule::execute");
    auto exec_result = tm.execute(cases, "./fake_binary");
    assert(exec_result.total == cases.size());
    PASS();

    TEST("TestingModule::computeReqCoverage");
    std::vector<aise::RequirementItem> reqs;
    aise::RequirementItem r1, r2;
    r1.id = "SRS-AISE_F-001";
    r2.id = "SRS-AISE_F-002";
    reqs.push_back(r1);
    reqs.push_back(r2);

    std::vector<aise::TestCase> tc_list;
    aise::TestCase tc;
    tc.req_id = "SRS-AISE_F-001";
    tc_list.push_back(tc);
    tc.req_id = "SRS-AISE_F-002";
    tc_list.push_back(tc);

    double cov = tm.computeReqCoverage(reqs, tc_list);
    assert(cov == 1.0);
    PASS();
}

static void test_engine_process_request() {
    TEST("Engine::processRequest - requirements.process");
    aise::Engine engine;
    engine.initialize();

    aise::ApiRequest req;
    req.operation = "requirements.process";
    req.payload   = "新需求条目";
    auto resp = engine.processRequest(req);
    assert(resp.code == 0);
    PASS();

    TEST("Engine::processRequest - code.generate");
    req.operation = "code.generate";
    req.payload   = "SRS-AISE_F-001,cpp,default";
    resp = engine.processRequest(req);
    assert(resp.code == 0);
    PASS();

    TEST("Engine::processRequest - testing.run");
    req.operation = "testing.run";
    req.payload   = "auto";
    resp = engine.processRequest(req);
    assert(resp.code == 0);
    PASS();

    TEST("Engine::processRequest - unknown operation");
    req.operation = "unknown.op";
    resp = engine.processRequest(req);
    assert(resp.code == -9);
    PASS();

    engine.shutdown();
}

int main() {
    std::cout << "========================================\n";
    std::cout << "  AISE Platform - Unit Tests\n";
    std::cout << "========================================\n\n";

    test_engine_initialization();
    test_requirements_process();
    test_codegen_generate();
    test_testing_module();
    test_engine_process_request();

    std::cout << "\n========================================\n";
    std::cout << "  Results: " << pass_count << "/" << test_count << " passed\n";
    std::cout << "========================================\n";

    return (pass_count == test_count) ? 0 : 1;
}