#include "aise/codegen.hpp"
#include <gtest/gtest.h>
#include <string>
#include <vector>

namespace aise {

class CodegenModuleTest : public ::testing::Test {
protected:
    CodegenModule module;
};

FRIEND_TEST(CodegenModuleTest, testCodegenModuleConstructor);
FRIEND_TEST(CodegenModuleTest, testGenerateCppNormal);
FRIEND_TEST(CodegenModuleTest, testGenerateJavaNormal);
FRIEND_TEST(CodegenModuleTest, testGenerateUnsupportedLanguage);
FRIEND_TEST(CodegenModuleTest, testGenerateEmptyReqId);
FRIEND_TEST(CodegenModuleTest, testGetTraceLinksExisting);
FRIEND_TEST(CodegenModuleTest, testGetTraceLinksNonExisting);
FRIEND_TEST(CodegenModuleTest, testGenerateCppSkeletonNormal);
FRIEND_TEST(CodegenModuleTest, testGenerateJavaSkeletonNormal);

TEST_F(CodegenModuleTest, testCodegenModuleConstructor) {
    auto links = module.getTraceLinks("SRS-AISE_F-001");
    ASSERT_EQ(links.size(), 1);
    EXPECT_EQ(links[0].req_id, "SRS-AISE_F-001");
    EXPECT_EQ(links[0].file_path, "src/requirements.cpp");
    EXPECT_FALSE(links[0].changed);
}

TEST_F(CodegenModuleTest, testGenerateCppNormal) {
    auto result = module.generate("REQ-001", "C++", "x86");
    EXPECT_TRUE(result.success);
    ASSERT_EQ(result.generated_files.size(), 1);
    EXPECT_EQ(result.generated_files[0], "REQ-001_impl.cpp");
    ASSERT_EQ(result.trace_links.size(), 1);
    EXPECT_EQ(result.trace_links[0].req_id, "REQ-001");
    EXPECT_EQ(result.output_dir, "./generated/REQ-001");
}

TEST_F(CodegenModuleTest, testGenerateJavaNormal) {
    auto result = module.generate("REQ-002", "Java", "ARM");
    EXPECT_TRUE(result.success);
    ASSERT_EQ(result.generated_files.size(), 1);
    EXPECT_EQ(result.generated_files[0], "REQ-002_impl.java");
    ASSERT_EQ(result.trace_links.size(), 1);
    EXPECT_EQ(result.trace_links[0].req_id, "REQ-002");
}

TEST_F(CodegenModuleTest, testGenerateUnsupportedLanguage) {
    auto result = module.generate("REQ-003", "Python", "x86");
    EXPECT_FALSE(result.success);
    EXPECT_EQ(result.error_msg, "Unsupported language: Python");
    EXPECT_TRUE(result.generated_files.empty());
}

TEST_F(CodegenModuleTest, testGenerateEmptyReqId) {
    auto result = module.generate("", "C++", "x86");
    EXPECT_TRUE(result.success);
    ASSERT_EQ(result.generated_files.size(), 1);
    EXPECT_EQ(result.generated_files[0], "_impl.cpp");
}

TEST_F(CodegenModuleTest, testGetTraceLinksExisting) {
    module.generate("REQ-001", "C++", "x86");
    auto links = module.getTraceLinks("REQ-001");
    ASSERT_EQ(links.size(), 1);
    EXPECT_EQ(links[0].file_path, "REQ-001_impl.cpp");
}

TEST_F(CodegenModuleTest, testGetTraceLinksNonExisting) {
    auto links = module.getTraceLinks("NONEXIST");
    EXPECT_TRUE(links.empty());
}

TEST_F(CodegenModuleTest, testGenerateCppSkeletonNormal) {
    RequirementItem req;
    req.id = "REQ-TEST";
    req.title = "Test Requirement";
    req.description = "Test Desc";
    std::string code = module.generateCppSkeleton(req);
    EXPECT_THAT(code, testing::HasSubstr("// Requirement: REQ-TEST - Test Requirement"));
    EXPECT_THAT(code, testing::HasSubstr("class REQModule"));
    EXPECT_THAT(code, testing::HasSubstr("void execute()"));
}

TEST_F(CodegenModuleTest, testGenerateJavaSkeletonNormal) {
    RequirementItem req;
    req.id = "REQ-JAVA";
    req.title = "Java Requirement";
    req.description = "Java Desc";
    std::string code = module.generateJavaSkeleton(req);
    EXPECT_THAT(code, testing::HasSubstr("// Requirement: REQ-JAVA - Java Requirement"));
    EXPECT_THAT(code, testing::HasSubstr("public class REQModule"));
    EXPECT_THAT(code, testing::HasSubstr("System.out.println"));
}

} // namespace aise