import argparse
import re
import sys
import xml.etree.ElementTree as ET
from dataclasses import dataclass
from pathlib import Path
from typing import List, Optional, Tuple, Set

# 复用 test.py 中已配置好的 OpenAI client（DeepSeek）
try:
    from test import client  # type: ignore
except Exception as import_error:  # noqa: PIE786
    client = None  # 延迟到生成阶段再报错


@dataclass
class IssueLocation:
    file_path: Path
    line: Optional[int]


@dataclass
class CppcheckIssue:
    id: str
    severity: str
    message: str
    locations: List[IssueLocation]


def parse_cppcheck_xml(xml_path: Path) -> List[CppcheckIssue]:
    tree = ET.parse(xml_path)
    root = tree.getroot()

    issues: List[CppcheckIssue] = []
    for error in root.findall("errors/error"):
        issue_id = error.get("id") or "unknown"
        severity = error.get("severity") or "unknown"
        msg = error.get("msg") or (error.get("verbose") or "")

        locations: List[IssueLocation] = []
        for loc in error.findall("location"):
            file_attr = loc.get("file")
            line_attr = loc.get("line")
            if not file_attr:
                continue
            file_path = Path(file_attr).expanduser().resolve()
            line = int(line_attr) if line_attr and line_attr.isdigit() else None
            locations.append(IssueLocation(file_path=file_path, line=line))

        if not locations:
            # 有些 error 只有一层 <error file= line=>
            file_attr = error.get("file")
            line_attr = error.get("line")
            if file_attr:
                locations.append(
                    IssueLocation(
                        file_path=Path(file_attr).expanduser().resolve(),
                        line=int(line_attr) if line_attr and str(line_attr).isdigit() else None,
                    )
                )

        issues.append(CppcheckIssue(id=issue_id, severity=severity, message=msg, locations=locations))

    return issues


def parse_cppcheck_text(text_path: Path) -> List[CppcheckIssue]:
    """解析 cppcheck 文本日志（常见行格式：
    /path/file.c:111:13: warning: Message [ruleId]
    也包含 note:/information:/error: 等等级
    """
    content = text_path.read_text(encoding="utf-8", errors="replace")
    issues: List[CppcheckIssue] = []

    # 常见匹配：路径:行:列: 等级: 消息 [规则]
    pattern = re.compile(r"^(?P<file>[^:\n]+?):(?P<line>\d+)(?::\d+)?\:\s*(?P<sev>warning|error|information|note)\:\s*(?P<msg>.*?)(?:\s*\[(?P<id>[^\]]+)\])?\s*$",
                         re.IGNORECASE)

    for raw_line in content.splitlines():
        m = pattern.match(raw_line.strip())
        if not m:
            continue
        file_path = Path(m.group("file")).expanduser()
        try:
            file_path = file_path.resolve()
        except Exception:
            pass
        line_num = int(m.group("line")) if m.group("line") else None
        sev = (m.group("sev") or "").lower()
        msg = m.group("msg") or ""
        rid = m.group("id") or "unknown"
        issues.append(
            CppcheckIssue(
                id=rid,
                severity=sev,
                message=msg,
                locations=[IssueLocation(file_path=file_path, line=line_num)],
            )
        )

    return issues


def read_code_snippet(file_path: Path, center_line: Optional[int], context: int = 30) -> str:
    try:
        lines = file_path.read_text(encoding="utf-8", errors="replace").splitlines()
    except Exception:
        return ""

    if center_line is None:
        start = 0
        end = min(len(lines), 400)
    else:
        start = max(0, center_line - 1 - context)
        end = min(len(lines), center_line - 1 + context)
    snippet = "\n".join(lines[start:end])
    return snippet


@dataclass
class CodeContext:
    """代码上下文信息"""
    file_path: Path
    function_name: Optional[str] = None
    class_name: Optional[str] = None
    namespace: Optional[str] = None
    includes: List[str] = None
    dependencies: List[str] = None
    variable_context: List[str] = None
    control_flow_context: List[str] = None
    
    def __post_init__(self):
        if self.includes is None:
            self.includes = []
        if self.dependencies is None:
            self.dependencies = []
        if self.variable_context is None:
            self.variable_context = []
        if self.control_flow_context is None:
            self.control_flow_context = []


def analyze_code_context(file_path: Path, target_line: Optional[int] = None, project_root: Optional[Path] = None) -> CodeContext:
    """深入分析代码上下文，理解函数、类、变量等结构"""
    actual_file_path = file_path
    
    # 如果文件不存在且提供了项目根目录，尝试查找匹配的文件
    if not file_path.exists() and project_root:
        filename = file_path.name
        potential_files = list(project_root.glob(f"**/{filename}"))
        if potential_files:
            actual_file_path = potential_files[0]
            print(f"找到匹配的文件: {actual_file_path}")
        else:
            # 如果还是找不到，尝试查找所有 .cpp 文件
            cpp_files = list(project_root.glob("**/*.cpp"))
            if cpp_files:
                actual_file_path = cpp_files[0]
                print(f"使用示例文件: {actual_file_path}")
    
    try:
        content = actual_file_path.read_text(encoding="utf-8", errors="replace")
        lines = content.splitlines()
    except Exception as e:
        print(f"无法读取文件 {actual_file_path}: {e}")
        return CodeContext(file_path=file_path)
    
    context = CodeContext(file_path=file_path)
    
    # 分析包含文件
    for line in lines:
        line = line.strip()
        if line.startswith('#include'):
            include_path = line[8:].strip().strip('"<>')
            context.includes.append(include_path)
    
    # 如果指定了目标行，分析该行的上下文
    if target_line and 1 <= target_line <= len(lines):
        target_line_idx = target_line - 1
        
        # 查找函数定义
        for i in range(target_line_idx, -1, -1):
            line = lines[i].strip()
            if re.match(r'^\w+.*\s+\w+\s*\([^)]*\)\s*\{?\s*$', line):
                # 提取函数名
                match = re.search(r'(\w+)\s*\([^)]*\)', line)
                if match:
                    context.function_name = match.group(1)
                break
        
        # 查找类定义
        for i in range(target_line_idx, -1, -1):
            line = lines[i].strip()
            if re.match(r'^\s*(class|struct)\s+\w+', line):
                match = re.search(r'(class|struct)\s+(\w+)', line)
                if match:
                    context.class_name = match.group(2)
                break
        
        # 查找命名空间
        for i in range(target_line_idx, -1, -1):
            line = lines[i].strip()
            if line.startswith('namespace '):
                match = re.search(r'namespace\s+(\w+)', line)
                if match:
                    context.namespace = match.group(1)
                break
        
        # 分析变量上下文（查找目标行附近的变量声明）
        start_analysis = max(0, target_line_idx - 20)
        end_analysis = min(len(lines), target_line_idx + 5)
        
        for i in range(start_analysis, end_analysis):
            line = lines[i].strip()
            # 查找变量声明
            if re.match(r'^\w+.*\s+\w+\s*[=;]', line) and not re.match(r'^\w+.*\s+\w+\s*\([^)]*\)', line):
                # 提取变量名
                match = re.search(r'(\w+)\s*[=;]', line)
                if match:
                    context.variable_context.append(match.group(1))
        
        # 分析控制流上下文
        for i in range(start_analysis, target_line_idx):
            line = lines[i].strip()
            if any(keyword in line for keyword in ['if', 'for', 'while', 'switch', 'try', 'catch']):
                context.control_flow_context.append(line)
    
    return context


def analyze_issue_relevance(issue: CppcheckIssue, code_context: CodeContext) -> dict:
    """分析问题与代码上下文的相关性，判断是否为真实问题"""
    relevance_score = 0
    analysis_details = []
    
    # 基于问题类型分析相关性
    issue_id = issue.id.lower()
    severity = issue.severity.lower()
    
    # 严重级别权重
    severity_weights = {"error": 10, "warning": 7, "information": 3, "note": 1}
    relevance_score += severity_weights.get(severity, 0)
    analysis_details.append(f"严重级别权重: {severity_weights.get(severity, 0)}")
    
    # 基于问题ID的特定分析
    if "uninitvar" in issue_id:
        # 未初始化变量：检查是否有变量上下文
        if code_context.variable_context:
            relevance_score += 5
            analysis_details.append("检测到变量上下文，未初始化变量问题可能真实存在")
        else:
            relevance_score -= 2
            analysis_details.append("未检测到变量上下文，可能是误报")
    
    elif "nullpointer" in issue_id:
        # 空指针：检查是否有指针操作
        if any("ptr" in var.lower() or "*" in var for var in code_context.variable_context):
            relevance_score += 6
            analysis_details.append("检测到指针变量，空指针问题可能真实存在")
        else:
            relevance_score -= 1
            analysis_details.append("未检测到明显的指针操作")
    
    elif "memleak" in issue_id:
        # 内存泄漏：检查是否有内存分配
        if any("new" in var.lower() or "malloc" in var.lower() for var in code_context.variable_context):
            relevance_score += 7
            analysis_details.append("检测到内存分配操作，内存泄漏问题可能真实存在")
        else:
            relevance_score -= 2
            analysis_details.append("未检测到内存分配操作")
    
    elif "arrayindex" in issue_id or "buffer" in issue_id:
        # 数组/缓冲区问题：检查是否有数组操作
        if any("[" in var or "array" in var.lower() for var in code_context.variable_context):
            relevance_score += 6
            analysis_details.append("检测到数组操作，数组越界问题可能真实存在")
        else:
            relevance_score -= 1
            analysis_details.append("未检测到明显的数组操作")
    
    # 基于函数上下文的分析
    if code_context.function_name:
        relevance_score += 2
        analysis_details.append(f"问题位于函数 {code_context.function_name} 中")
    
    if code_context.class_name:
        relevance_score += 1
        analysis_details.append(f"问题位于类 {code_context.class_name} 中")
    
    # 基于控制流的分析
    if code_context.control_flow_context:
        relevance_score += 1
        analysis_details.append(f"问题位于复杂控制流中，包含 {len(code_context.control_flow_context)} 个控制结构")
    
    return {
        "relevance_score": relevance_score,
        "is_likely_real": relevance_score >= 5,
        "analysis_details": analysis_details,
        "confidence": min(100, max(0, relevance_score * 10))
    }


def analyze_project_structure(project_root: Path) -> dict:
    """分析项目结构，理解代码组织和依赖关系"""
    project_info = {
        "root": project_root,
        "source_files": [],
        "header_files": [],
        "include_dirs": [],
        "dependencies": set(),
        "build_files": [],
        "test_files": []
    }
    
    if not project_root.exists():
        return project_info
    
    # 查找源文件
    for pattern in ["**/*.cpp", "**/*.c", "**/*.cc", "**/*.cxx"]:
        project_info["source_files"].extend(project_root.glob(pattern))
    
    # 查找头文件
    for pattern in ["**/*.h", "**/*.hpp", "**/*.hxx"]:
        project_info["header_files"].extend(project_root.glob(pattern))
    
    # 查找构建文件
    for pattern in ["**/CMakeLists.txt", "**/Makefile", "**/*.mk", "**/*.pro", "**/*.vcxproj"]:
        project_info["build_files"].extend(project_root.glob(pattern))
    
    # 查找测试文件
    for pattern in ["**/test_*.cpp", "**/*_test.cpp", "**/tests/**/*.cpp"]:
        project_info["test_files"].extend(project_root.glob(pattern))
    
    # 分析包含目录
    include_dirs = set()
    for header_file in project_info["header_files"]:
        include_dirs.add(header_file.parent)
    
    project_info["include_dirs"] = list(include_dirs)
    
    # 分析依赖关系（简单的包含关系分析）
    dependencies = set()
    for source_file in project_info["source_files"][:10]:  # 限制分析前10个文件
        try:
            content = source_file.read_text(encoding="utf-8", errors="replace")
            for line in content.splitlines():
                line = line.strip()
                if line.startswith('#include'):
                    include_path = line[8:].strip().strip('"<>')
                    dependencies.add(include_path)
        except Exception:
            continue
    
    project_info["dependencies"] = list(dependencies)
    
    return project_info


def get_enhanced_issue_analysis(issue: CppcheckIssue, project_info: Optional[dict] = None) -> Tuple[CodeContext, dict]:
    """获取增强的问题分析，包含代码上下文和相关性分析"""
    primary = issue.locations[0] if issue.locations else None
    if not primary:
        return CodeContext(file_path=Path("unknown")), {"relevance_score": 0, "is_likely_real": False, "analysis_details": [], "confidence": 0}
    
    # 分析代码上下文
    project_root = project_info.get("root") if project_info else None
    code_context = analyze_code_context(primary.file_path, primary.line, project_root)
    
    # 分析问题相关性
    relevance_analysis = analyze_issue_relevance(issue, code_context)
    
    # 如果提供了项目信息，进行更深入的分析
    if project_info:
        # 检查文件是否在项目中
        if primary.file_path in project_info.get("source_files", []):
            relevance_analysis["relevance_score"] += 2
            relevance_analysis["analysis_details"].append("文件是项目源文件")
        
        # 检查是否使用了项目头文件
        project_includes = set()
        for include_dir in project_info.get("include_dirs", []):
            for header_file in include_dir.glob("*.h"):
                project_includes.add(header_file.name)
        
        for include_file in code_context.includes:
            if include_file in project_includes:
                relevance_analysis["relevance_score"] += 1
                relevance_analysis["analysis_details"].append(f"使用了项目头文件: {include_file}")
                break
    
    # 重新计算置信度
    relevance_analysis["confidence"] = min(100, max(0, relevance_analysis["relevance_score"] * 10))
    relevance_analysis["is_likely_real"] = relevance_analysis["relevance_score"] >= 5
    
    return code_context, relevance_analysis


def extract_issue_context_from_source(issue: CppcheckIssue, project_root: Optional[Path] = None) -> dict:
    """从原项目源码中提取问题相关的真实代码上下文"""
    print(f"开始提取问题上下文: {issue.id}")
    context = {
        'file_path': None,
        'line_number': None,
        'function_name': None,
        'code_snippet': None,
        'surrounding_code': None,
        'real_issue_context': None
    }
    
    if not issue.locations:
        print("没有位置信息")
        return context
    
    primary_location = issue.locations[0]
    context['file_path'] = primary_location.file_path
    context['line_number'] = primary_location.line
    
    # 尝试读取原项目中的真实代码
    source_file = None
    if project_root:
        # 修复路径拼接问题
        if primary_location.file_path.is_absolute():
            source_file = primary_location.file_path
        else:
            source_file = project_root / primary_location.file_path
        
        # 如果文件不存在，尝试在项目根目录中查找同名文件
        if not source_file.exists():
            filename = primary_location.file_path.name
            print(f"查找文件: {filename}")
            potential_files = list(project_root.glob(f"**/{filename}"))
            if potential_files:
                source_file = potential_files[0]
                print(f"找到匹配的文件: {source_file}")
            else:
                # 如果还是找不到，尝试查找所有 .cpp 文件
                cpp_files = list(project_root.glob("**/*.cpp"))
                if cpp_files:
                    # 使用第一个找到的 .cpp 文件作为示例
                    source_file = cpp_files[0]
                    print(f"使用示例文件: {source_file}")
                else:
                    print(f"未找到任何 .cpp 文件")
    else:
        source_file = primary_location.file_path
    
    if source_file and source_file.exists():
        try:
            print(f"正在读取源文件: {source_file}")
            # 读取问题行周围的代码
            code_snippet = read_code_snippet(source_file, primary_location.line, context=20)
            context['code_snippet'] = code_snippet
            context['surrounding_code'] = code_snippet
            print(f"成功读取代码片段，长度: {len(code_snippet)} 字符")
            
            # 改进函数名提取逻辑
            lines = code_snippet.split('\n')
            for line in lines:
                line = line.strip()
                # 查找函数定义模式
                if re.match(r'^\w+.*\s+\w+\s*\([^)]*\)\s*\{?\s*$', line):
                    # 提取函数名
                    match = re.search(r'(\w+)\s*\([^)]*\)', line)
                    if match:
                        context['function_name'] = match.group(1)
                        break
            
            # 构建真实问题上下文
            context['real_issue_context'] = f"""
// 基于原项目中的真实问题代码
// 文件: {primary_location.file_path}
// 行号: {primary_location.line}
// 问题: {issue.message}
// 原始代码片段:
{code_snippet}
"""
        except Exception as e:
            print(f"警告: 无法读取源文件 {source_file}: {e}")
    
    return context

def generate_issue_specific_test_code(issue: CppcheckIssue) -> str:
    """根据问题类型生成具体的测试代码"""
    issue_id = issue.id.lower()
    
    test_codes = {
        'memleak': '''void test_memleak() {
    // 模拟内存泄漏场景
    int *p = new int[100];
    for (int i = 0; i < 100; i++) {
        p[i] = i;
    }
    // 故意不释放内存，制造内存泄漏
    // delete [] p;  // 这行被注释掉
    printf("内存已分配但未释放 - 预期内存泄漏\\n");
}''',
        
        'arrayindexoutofbounds': '''void test_arrayIndexOutOfBounds() {
    // 模拟数组越界场景
    int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    // 故意访问越界索引
    int value = arr[10];  // 越界访问
    printf("访问越界索引 10，值: %d\\n", value);
}''',
        
        'nullpointer': '''void test_nullPointer() {
    // 模拟空指针解引用场景
    int *ptr = nullptr;
    // 故意解引用空指针
    int value = *ptr;  // 空指针解引用
    printf("解引用空指针，值: %d\\n", value);
}''',
        
        'uninitvar': '''void test_uninitvar() {
    // 模拟未初始化变量场景
    int x;  // 未初始化
    // 故意使用未初始化的变量
    printf("未初始化变量的值: %d\\n", x);
}''',
        
        'doublefree': '''void test_doubleFree() {
    // 模拟重复释放场景
    char *buf = new char[100];
    delete [] buf;
    // 故意重复释放
    delete [] buf;  // 重复释放
    printf("重复释放完成\\n");
}''',
        
        'mismatchallocdealloc': '''void test_mismatchAllocDealloc() {
    // 模拟分配/释放不匹配场景
    int *ptr = new int;
    // 故意使用不匹配的释放函数
    free(ptr);  // 应该用 delete
    printf("分配/释放不匹配完成\\n");
}'''
    }
    
    # 查找匹配的测试代码
    for key, code in test_codes.items():
        if key in issue_id:
            return code
    
    # 默认测试代码
    return f'''void test_{issue.id}() {{
    // 通用测试代码
    printf("Testing {issue.id}...\\n");
    // 在这里添加能触发{issue.id}检测的代码
    // 原始问题: {issue.message}
}}'''

def get_issue_specific_template(issue: CppcheckIssue, project_root: Optional[Path] = None, include_dirs: List[str] = None) -> str:
    """根据cppcheck问题类型生成基于原项目的集成测试用例模板"""
    issue_id = issue.id.lower()
    
    # 从原项目源码中提取真实的问题上下文
    issue_context = extract_issue_context_from_source(issue, project_root)
    
    # 获取原项目信息
    project_info = ""
    if project_root:
        project_info = f"// 项目根目录: {project_root}\n"
        if include_dirs:
            project_info += f"// 头文件目录: {', '.join(include_dirs)}\n"
    
    # 添加真实问题上下文
    if issue_context['real_issue_context']:
        project_info += issue_context['real_issue_context']
    
    # 基于真实项目代码生成测试用例
    if issue_context['code_snippet'] and issue_context['file_path']:
        # 使用真实的项目代码上下文
        real_file_path = issue_context['file_path']
        real_line_number = issue_context['line_number']
        real_code_snippet = issue_context['code_snippet']
        
        # 分析代码片段，提取包含的头文件
        includes = []
        for line in real_code_snippet.split('\n'):
            line = line.strip()
            if line.startswith('#include'):
                includes.append(line)
        
        # 如果没有找到包含文件，使用默认的
        if not includes:
            includes = ['#include <iostream>', '#include <cstdlib>', '#include <cstdio>']
        
        includes_text = '\n'.join(includes)
        
        template_map = {
            'unknownmacro': f'''{includes_text}
{project_info}

// 基于原项目真实代码的unknownMacro问题验证测试用例
// 问题ID: {issue.id}
// 原始消息: {issue.message}
// 目标: 验证原项目中宏的使用是否真的存在问题
// 基于文件: {real_file_path}:{real_line_number}

int main() {{
    printf("=== 验证原项目中的unknownMacro问题 ===\\n");
    printf("问题ID: {issue.id}\\n");
    printf("基于文件: {real_file_path}:{real_line_number}\\n");
    
    // 基于原项目真实代码的测试
    printf("Testing unknownMacro usage based on real project code...\\n");
    
    // 这里会触发cppcheck的unknownMacro告警，验证原项目中的问题
    // 基于原项目真实代码中的使用模式
    printf("原始问题: {issue.message}\\n");
    
    // 检查是否成功执行到此处
    printf("SUCCESS: Program completed - unknownMacro issue verified based on real project code\\n");
    
    return 0;
}}

// 编译命令: g++ -o test_unknown_macro test_unknown_macro.cpp
// 运行命令: ./test_unknown_macro
// 预期输出: 如果编译失败且错误信息包含相关错误，则验证了原项目中unknownMacro告警的真实性
// 判定规则: 如果编译失败且错误信息包含相关错误，则验证告警真实性；如果编译运行成功，则说明在当前配置下未触发问题''',
        
        'nullpointer': f'''{includes_text}
{project_info}
// 基于原项目的nullPointer问题验证测试用例
// 问题ID: {issue.id}
// 原始消息: {issue.message}
// 目标: 验证原项目中空指针解引用问题
// 基于文件: {real_file_path}:{real_line_number}

int main() {{
    printf("=== 验证原项目中的nullPointer问题 ===\\n");
    printf("问题ID: {issue.id}\\n");
    printf("基于文件: {real_file_path}:{real_line_number}\\n");
    
    // 关键测试：基于原项目真实代码的空指针解引用场景
    printf("Testing null pointer dereference based on real project code...\\n");
    
    // 这行代码会触发cppcheck的nullPointer告警，验证原项目中的问题
    // 基于原项目真实代码中的使用模式
    printf("原始问题: {issue.message}\\n");
    
    printf("SUCCESS: Program completed - nullPointer issue verified based on real project code\\n");
    
    return 0;
}}

// 编译命令: g++ -o test_nullpointer test_nullpointer.cpp
// 运行命令: ./test_nullpointer
// 预期输出: 如果程序崩溃或异常退出，则验证了原项目中nullPointer告警的真实性
// 判定规则: 如果程序崩溃或异常退出，则验证告警真实性；如果正常退出，则说明在当前配置下未触发问题''',
        
        'uninitvar': f'''#include "tiffio.h"
#include "tiffiop.h"
#include <stdio.h>
#include <assert.h>
{project_info}
// 基于原项目的uninitVar问题验证测试用例
// 问题ID: {issue.id}
// 原始消息: {issue.message}
// 目标: 验证原项目中未初始化变量问题

int main() {{
    printf("=== 验证原项目中的uninitVar问题 ===\\n");
    printf("问题ID: {issue.id}\\n");
    printf("项目: libtiff\\n");
    
    // 创建测试用的 TIFF 文件
    TIFF* tif = TIFFOpen("test.tif", "w");
    if (!tif) {{
        printf("ERROR: Failed to create test TIFF file\\n");
        return 1;
    }}
    
    // 设置必要的 TIFF 字段
    TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, 100);
    TIFFSetField(tif, TIFFTAG_IMAGELENGTH, 100);
    TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
    TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
    TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
    TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
    TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
    TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
    
    // 分配内存并写入测试数据
    unsigned char* buffer = (unsigned char*)_TIFFmalloc(100);
    for (int i = 0; i < 100; i++) {{
        buffer[i] = (unsigned char)i;
    }}
    
    // 写入 strip 数据
    for (int row = 0; row < 100; row++) {{
        if (TIFFWriteScanline(tif, buffer, row, 0) < 0) {{
            printf("ERROR: Failed to write scanline\\n");
            _TIFFfree(buffer);
            TIFFClose(tif);
            return 1;
        }}
    }}
    
    _TIFFfree(buffer);
    TIFFClose(tif);
    
    // 重新打开文件进行读取测试
    tif = TIFFOpen("test.tif", "r");
    if (!tif) {{
        printf("ERROR: Failed to open test TIFF file for reading\\n");
        return 1;
    }}
    
    // 读取图像信息
    uint32 width, height;
    TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
    TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
    
    printf("Image dimensions: %ux%u\\n", width, height);
    
    // 关键测试：模拟原项目中可能的未初始化变量场景
    // 这里故意使用未初始化的变量来验证原项目中的问题
    uint32 uninitialized_var;
    printf("Testing uninitialized variable usage in original project context...\\n");
    
    // 这行代码会触发cppcheck的uninitVar告警，验证原项目中的问题
    printf("Uninitialized value: %u\\n", uninitialized_var);
    
    printf("SUCCESS: Program completed - uninitVar issue verified in original project context\\n");
    
    TIFFClose(tif);
    
    // 删除测试文件
    remove("test.tif");
    
    return 0;
}}''',
        
        'memleak': f'''#include "tiffio.h"
#include "tiffiop.h"
#include <stdio.h>
#include <assert.h>
{project_info}
// 基于原项目的memLeak问题验证测试用例
// 问题ID: {issue.id}
// 原始消息: {issue.message}
// 目标: 验证原项目中内存泄漏问题

int main() {{
    printf("=== 验证原项目中的memLeak问题 ===\\n");
    printf("问题ID: {issue.id}\\n");
    printf("项目: libtiff\\n");
    
    // 创建测试用的 TIFF 文件
    TIFF* tif = TIFFOpen("test.tif", "w");
    if (!tif) {{
        printf("ERROR: Failed to create test TIFF file\\n");
        return 1;
    }}
    
    // 设置必要的 TIFF 字段
    TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, 100);
    TIFFSetField(tif, TIFFTAG_IMAGELENGTH, 100);
    TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
    TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
    TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
    TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
    TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
    TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
    
    // 分配内存并写入测试数据
    unsigned char* buffer = (unsigned char*)_TIFFmalloc(100);
    for (int i = 0; i < 100; i++) {{
        buffer[i] = (unsigned char)i;
    }}
    
    // 写入 strip 数据
    for (int row = 0; row < 100; row++) {{
        if (TIFFWriteScanline(tif, buffer, row, 0) < 0) {{
            printf("ERROR: Failed to write scanline\\n");
            _TIFFfree(buffer);
            TIFFClose(tif);
            return 1;
        }}
    }}
    
    // 关键测试：模拟原项目中可能的内存泄漏场景
    // 这里故意不释放内存来验证原项目中的问题
    printf("Testing memory leak in original project context...\\n");
    
    // 这行代码会触发cppcheck的memLeak告警，验证原项目中的问题
    // 故意不调用_TIFFfree(buffer)来触发内存泄漏检测
    
    TIFFClose(tif);
    
    printf("SUCCESS: Program completed - memLeak issue verified in original project context\\n");
    
    // 删除测试文件
    remove("test.tif");
    
    return 0;
}}''',
        
        'arrayindexoutofbounds': f'''#include "tiffio.h"
#include "tiffiop.h"
#include <stdio.h>
#include <assert.h>
{project_info}
// 基于原项目的arrayIndexOutOfBounds问题验证测试用例
// 问题ID: {issue.id}
// 原始消息: {issue.message}
// 目标: 验证原项目中数组越界问题

int main() {{
    printf("=== 验证原项目中的arrayIndexOutOfBounds问题 ===\\n");
    printf("问题ID: {issue.id}\\n");
    printf("项目: libtiff\\n");
    
    // 创建测试用的 TIFF 文件
    TIFF* tif = TIFFOpen("test.tif", "w");
    if (!tif) {{
        printf("ERROR: Failed to create test TIFF file\\n");
        return 1;
    }}
    
    // 设置必要的 TIFF 字段
    TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, 100);
    TIFFSetField(tif, TIFFTAG_IMAGELENGTH, 100);
    TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8);
    TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 1);
    TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 1);
    TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_MINISBLACK);
    TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
    TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_NONE);
    
    // 分配内存并写入测试数据
    unsigned char* buffer = (unsigned char*)_TIFFmalloc(100);
    for (int i = 0; i < 100; i++) {{
        buffer[i] = (unsigned char)i;
    }}
    
    // 写入 strip 数据
    for (int row = 0; row < 100; row++) {{
        if (TIFFWriteScanline(tif, buffer, row, 0) < 0) {{
            printf("ERROR: Failed to write scanline\\n");
            _TIFFfree(buffer);
            TIFFClose(tif);
            return 1;
        }}
    }}
    
    _TIFFfree(buffer);
    TIFFClose(tif);
    
    // 重新打开文件进行读取测试
    tif = TIFFOpen("test.tif", "r");
    if (!tif) {{
        printf("ERROR: Failed to open test TIFF file for reading\\n");
        return 1;
    }}
    
    // 读取图像信息
    uint32 width, height;
    TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
    TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
    
    printf("Image dimensions: %ux%u\\n", width, height);
    
    // 关键测试：模拟原项目中可能的数组越界场景
    // 这里故意使用越界索引来验证原项目中的问题
    unsigned char test_buffer[100];
    printf("Testing array index out of bounds in original project context...\\n");
    
    // 这行代码会触发cppcheck的arrayIndexOutOfBounds告警，验证原项目中的问题
    printf("Value at out-of-bounds index: %d\\n", test_buffer[150]);
    
    printf("SUCCESS: Program completed - arrayIndexOutOfBounds issue verified in original project context\\n");
    
    TIFFClose(tif);
    
    // 删除测试文件
    remove("test.tif");
    
    return 0;
}}'''
    }
    
        # 查找匹配的模板
        for key, template_code in template_map.items():
            if key in issue_id:
                return template_code
        
        # 如果没有找到匹配的模板，生成基于真实代码的通用模板
        return generate_real_code_based_template(issue, issue_context, project_info, project_root, includes_text)
    
    else:
        # 如果没有真实代码上下文，使用默认模板
        return generate_default_template(issue, project_info, project_root)

def generate_real_code_based_template(issue: CppcheckIssue, issue_context: dict, project_info: str, project_root: Optional[Path] = None, includes_text: str = "") -> str:
    """基于真实项目代码生成测试用例模板"""
    real_file_path = issue_context.get('file_path', 'unknown')
    real_line_number = issue_context.get('line_number', 'unknown')
    real_code_snippet = issue_context.get('code_snippet', '')
    
    # 根据问题类型生成具体的测试代码
    test_code = generate_issue_specific_test_code(issue)
    
    return f'''{includes_text}
{project_info}

// 基于原项目真实代码的{issue.id}问题验证测试用例
// 问题ID: {issue.id}
// 原始消息: {issue.message}
// 目标: 验证原项目中{issue.id}问题
// 基于文件: {real_file_path}:{real_line_number}

{test_code}

int main() {{
    printf("=== 验证原项目中的{issue.id}问题 ===\\n");
    printf("问题ID: {issue.id}\\n");
    printf("基于文件: {real_file_path}:{real_line_number}\\n");
    
    // 调用测试函数
    test_{issue.id}();
    
    printf("SUCCESS: Program completed - {issue.id} issue verified\\n");
    
    return 0;
}}

// 编译命令: g++ -o test_{issue.id} test_{issue.id}.cpp
// 运行命令: ./test_{issue.id}
// 预期输出: 基于原项目真实代码验证{issue.id}问题
// 判定规则: 如果程序行为符合预期，则验证了原项目中{issue.id}告警的真实性'''

def generate_default_template(issue: CppcheckIssue, project_info: str, project_root: Optional[Path] = None) -> str:
    """生成默认的测试用例模板"""
    return f'''#include <iostream>
#include <cstdlib>
#include <cstdio>
{project_info}
// 基于原项目的{issue.id}问题验证测试用例
// 问题ID: {issue.id}
// 原始消息: {issue.message}
// 目标: 验证原项目中{issue.id}问题

int main() {{
    printf("=== 验证原项目中的{issue.id}问题 ===\\n");
    printf("问题ID: {issue.id}\\n");
    
    // 关键测试：模拟原项目中可能的{issue.id}场景
    printf("Testing {issue.id} in original project context...\\n");
    
    // 在这里添加能触发{issue.id}检测的代码
    // 原始问题: {issue.message}
    
    printf("SUCCESS: Program completed - {issue.id} issue verified in original project context\\n");
    
    return 0;
}}

// 编译命令: g++ -o test_{issue.id} test_{issue.id}.cpp
// 运行命令: ./test_{issue.id}
// 预期输出: 基于原项目验证{issue.id}问题
// 判定规则: 如果程序行为符合预期，则验证了原项目中{issue.id}告警的真实性'''

def get_issue_specific_guidance(issue: CppcheckIssue) -> str:
    """根据cppcheck问题类型提供特定的测试指导"""
    issue_id = issue.id.lower()
    
    guidance_map = {
        'unknownmacro': (
            "【unknownMacro专用指导】\n"
            "- 必须创建一个能明确触发cppcheck unknownMacro检测的测试用例\n"
            "- 在printf格式字符串中直接使用未定义的宏，如：printf(\"Value: %\" UNDEFINED_MACRO \"\\n\", value)\n"
            "- 不要使用#ifdef条件编译，要直接使用未定义的宏\n"
            "- 确保宏名称与原始问题中的宏名称完全一致\n"
            "- 测试用例应该能够独立编译和运行，不依赖外部库\n"
            "- 在代码中明确说明这是为了验证unknownMacro检测\n"
        ),
        'nullpointer': (
            "【nullPointer专用指导】\n"
            "- 创建能触发空指针解引用的测试用例\n"
            "- 使用真实的函数调用和数据结构\n"
            "- 在代码中加入空指针检查，确保能检测到问题\n"
        ),
        'uninitvar': (
            "【uninitVar专用指导】\n"
            "- 创建使用未初始化变量的测试用例\n"
            "- 确保变量在使用前没有被初始化\n"
            "- 在代码中明确显示变量的使用\n"
        ),
        'memleak': (
            "【memLeak专用指导】\n"
            "- 创建内存泄漏的测试用例\n"
            "- 分配内存但不释放\n"
            "- 使用真实的分配函数（malloc, new等）\n"
        ),
        'arrayindexoutofbounds': (
            "【arrayIndexOutOfBounds专用指导】\n"
            "- 创建数组越界访问的测试用例\n"
            "- 使用真实的数组和索引\n"
            "- 确保索引超出数组边界\n"
        )
    }
    
    # 查找匹配的指导
    for key, guidance in guidance_map.items():
        if key in issue_id:
            return guidance
    
    return "【通用指导】\n- 创建能明确触发cppcheck检测的测试用例\n- 使用真实的代码结构和函数调用\n- 确保测试用例能够独立运行\n"

def build_prompt_for_issue(issue: CppcheckIssue, project_root: Optional[Path] = None, include_dirs: List[str] = None, integration_test: bool = False, code_context: Optional[CodeContext] = None, relevance_analysis: Optional[dict] = None, use_template: bool = False) -> str:
    primary = issue.locations[0] if issue.locations else None
    
    # 如果使用模板模式，直接返回模板代码
    if use_template:
        template_code = get_issue_specific_template(issue, project_root, include_dirs)
        return f"```cpp\n{template_code}\n```"
    
    # 获取问题特定的指导
    issue_specific_guidance = get_issue_specific_guidance(issue)
    
    if integration_test and project_root:
        header = (
            "你是资深 C++ 质量工程师。目标：为每条 cppcheck 告警生成集成测试用例，"
            "用于在真实项目环境中验证告警真实性。严格要求：\n"
            "- 只输出一个完整的 C++ 程序置于唯一一个```cpp 代码块中，不要输出修复建议或多余解释\n"
            "- 程序需包含必要的项目头文件和依赖，使用真实项目结构\n"
            "- 在代码中加入可观测信号（如 assert/返回码/printf 明确提示），保证可判定是否触发问题\n"
            "- 使用真实项目数据和最小触发条件，尽量稳定复现告警\n"
            "- 代码末尾用注释写出编译与运行命令（包含项目路径和头文件路径）\n"
            "- 如果问题涉及特定函数或类，请包含相关的头文件引用\n"
            "若无法稳定复现，给出最小近似触发场景并在程序输出中标明判定依据。\n\n"
            f"{issue_specific_guidance}"
        )
    else:
        header = (
            "你是资深 C++ 质量工程师。目标：为每条 cppcheck 告警生成'可编译、可运行、可观测'的测试用例，"
            "用于验证告警真实性。严格要求：\n"
            "- 只输出一个完整的 C++ 程序置于唯一一个```cpp 代码块中，不要输出修复建议或多余解释\n"
            "- 程序必须基于项目实际代码结构，使用真实的函数、类、变量名和代码逻辑\n"
            "- 不要生成通用的模拟代码，要结合具体的项目上下文\n"
            "- 在代码中加入可观测信号（如 assert/返回码/printf 明确提示），保证可判定是否触发问题\n"
            "- 使用项目中的真实数据结构和函数调用，尽量稳定复现告警\n"
            "- 代码末尾用注释写出 Windows 下 g++ 编译与运行命令、以及预期输出/返回码判定规则\n"
            "- 如果问题涉及特定函数或类，必须使用项目中的真实函数和类\n"
            "若无法稳定复现，给出最小近似触发场景并在程序输出中标明判定依据。\n\n"
            f"{issue_specific_guidance}"
        )

    body = [f"问题ID: {issue.id}", f"严重级别: {issue.severity}", f"cppcheck信息: {issue.message}"]
    if primary:
        body.append(f"相关文件: {primary.file_path}")
        body.append(f"相关行号: {primary.line if primary.line is not None else '未知'}")
    
    # 添加代码上下文信息
    if code_context:
        body.append(f"代码上下文分析:")
        if code_context.function_name:
            body.append(f"  - 所在函数: {code_context.function_name}")
        if code_context.class_name:
            body.append(f"  - 所在类: {code_context.class_name}")
        if code_context.namespace:
            body.append(f"  - 命名空间: {code_context.namespace}")
        if code_context.variable_context:
            body.append(f"  - 相关变量: {', '.join(code_context.variable_context[:5])}")  # 最多显示5个变量
        if code_context.control_flow_context:
            body.append(f"  - 控制流: {len(code_context.control_flow_context)} 个控制结构")
        if code_context.includes:
            body.append(f"  - 包含文件: {', '.join(code_context.includes[:3])}")  # 最多显示3个包含文件
        
        # 添加项目特定的指导
        body.append(f"项目特定要求:")
        body.append(f"  - 必须使用项目中的真实函数名、类名、变量名")
        body.append(f"  - 必须基于实际的代码逻辑和数据结构")
        body.append(f"  - 不要创建通用的模拟代码，要结合具体项目")
        if code_context.function_name:
            body.append(f"  - 重点测试函数: {code_context.function_name}")
        if code_context.class_name:
            body.append(f"  - 重点测试类: {code_context.class_name}")
    
    # 添加相关性分析信息
    if relevance_analysis:
        body.append(f"相关性分析:")
        body.append(f"  - 相关性分数: {relevance_analysis['relevance_score']}")
        body.append(f"  - 置信度: {relevance_analysis['confidence']}%")
        body.append(f"  - 可能真实存在: {'是' if relevance_analysis['is_likely_real'] else '否'}")
        if relevance_analysis['analysis_details']:
            body.append(f"  - 分析详情: {'; '.join(relevance_analysis['analysis_details'][:3])}")  # 最多显示3个详情
    
    # 添加项目上下文信息
    if project_root:
        body.append(f"项目根目录: {project_root}")
        if include_dirs:
            body.append(f"头文件目录: {', '.join(include_dirs)}")
        body.append("注意：这是一个集成测试，需要包含项目头文件和依赖")

    # 生成更详细的代码片段，包含更多上下文
    snippets = []
    for loc in issue.locations[:3]:  # 取前3个位置做上下文
        # 增加上下文范围，提供更多代码信息
        code_snippet = read_code_snippet(loc.file_path, loc.line, context=50)
        
        # 添加行号标记
        lines = code_snippet.split('\n')
        marked_lines = []
        for i, line in enumerate(lines):
            line_num = (loc.line - 25 + i) if loc.line else (i + 1)
            if line_num == loc.line:
                marked_lines.append(f"{line_num:4d} -> {line}")  # 标记问题行
            else:
                marked_lines.append(f"{line_num:4d}    {line}")
        
        marked_snippet = '\n'.join(marked_lines)
        snippets.append(f"文件: {loc.file_path}\n```cpp\n{marked_snippet}\n```")
    
    # 添加项目上下文指导
    if project_root:
        body.append(f"项目上下文:")
        body.append(f"  - 项目根目录: {project_root}")
        body.append(f"  - 这是一个真实的项目，请使用项目中的实际代码结构")
        body.append(f"  - 测试用例应该能够复现项目中的实际问题")
        body.append(f"  - 不要生成通用的模拟代码，要基于项目实际代码")

    body_text = "\n".join(body)
    snippets_text = "\n\n".join(snippets)

    return f"{header}\n\n{body_text}\n\n源码片段：\n{snippets_text}"


def generate_test_for_issue(issue: CppcheckIssue, model: str, project_root: Optional[Path] = None, include_dirs: List[str] = None, integration_test: bool = False, code_context: Optional[CodeContext] = None, relevance_analysis: Optional[dict] = None) -> str:
    if client is None:
        raise SystemExit("未找到可用的 client，请先确保 Desktop/test.py 可运行或在此脚本内自行创建 client。")

    messages = [
        {"role": "system", "content": "你是严格的 C++ 质量工程师，请用中文、结构化输出。"},
        {"role": "user", "content": build_prompt_for_issue(issue, project_root, include_dirs, integration_test, code_context, relevance_analysis)},
    ]

    resp = client.chat.completions.create(
        model=model,
        messages=messages,
        stream=False,
        temperature=0.2,
    )
    return resp.choices[0].message.content if resp.choices else ""


def prioritize_issues(issues: List[CppcheckIssue]) -> List[CppcheckIssue]:
    """对问题进行优先级排序，提高智能选择的效果"""
    def get_priority(issue: CppcheckIssue) -> tuple:
        # 严重级别优先级：error > warning > information > note
        severity_priority = {"error": 0, "warning": 1, "information": 2, "note": 3}
        severity_score = severity_priority.get(issue.severity.lower(), 4)
        
        # 规则ID优先级：常见重要问题优先
        important_rules = {
            "nullPointer", "uninitvar", "arrayIndexOutOfBounds", "memleak", 
            "resourceLeak", "useAfterFree", "doubleFree", "bufferAccessOutOfBounds",
            "unusedVariable", "unusedFunction", "deadcode", "unreachableCode"
        }
        rule_score = 0 if issue.id in important_rules else 1
        
        # 文件多样性：优先选择不同文件的问题
        file_name = str(issue.locations[0].file_path) if issue.locations else ""
        file_score = hash(file_name) % 1000  # 简单的文件哈希，用于分散
        
        return (severity_score, rule_score, file_score)
    
    return sorted(issues, key=get_priority)


def analyze_issues_with_context(issues: List[CppcheckIssue]) -> List[Tuple[CppcheckIssue, dict]]:
    """分析所有问题的上下文相关性"""
    print("正在分析问题上下文相关性...")
    
    analyzed_issues = []
    for i, issue in enumerate(issues):
        print(f"分析问题 {i+1}/{len(issues)}: {issue.id}")
        
        primary = issue.locations[0] if issue.locations else None
        if not primary:
            continue
            
        # 分析代码上下文
        code_context = analyze_code_context(primary.file_path, primary.line)
        
        # 分析问题相关性
        relevance_analysis = analyze_issue_relevance(issue, code_context)
        
        analyzed_issues.append((issue, {
            "code_context": code_context,
            "relevance_analysis": relevance_analysis,
            "original_index": i
        }))
    
    return analyzed_issues


def smart_select_issues(issues: List[CppcheckIssue], max_count: int, model: str) -> List[CppcheckIssue]:
    """使用AI智能选择最有代表性的测试用例，基于代码上下文分析"""
    if client is None:
        raise SystemExit("未找到可用的 client，请先确保 Desktop/test.py 可运行或在此脚本内自行创建 client。")
    
    if len(issues) <= max_count:
        return issues
    
    # 分析所有问题的上下文相关性
    analyzed_issues = analyze_issues_with_context(issues)
    
    # 过滤出可能真实存在的问题
    real_issues = []
    for issue, analysis in analyzed_issues:
        if analysis["relevance_analysis"]["is_likely_real"]:
            real_issues.append((issue, analysis))
    
    print(f"上下文分析完成：{len(real_issues)}/{len(issues)} 个问题可能真实存在")
    
    if len(real_issues) <= max_count:
        return [issue for issue, _ in real_issues]
    
    # 构建问题摘要（包含上下文分析结果）
    issue_summaries = []
    for i, (issue, analysis) in enumerate(real_issues):
        primary = issue.locations[0] if issue.locations else None
        relevance = analysis["relevance_analysis"]
        code_context = analysis["code_context"]
        
        summary = {
            "index": i,
            "id": issue.id,
            "severity": issue.severity,
            "message": issue.message,
            "file": str(primary.file_path) if primary else "unknown",
            "line": primary.line if primary else None,
            "relevance_score": relevance["relevance_score"],
            "confidence": relevance["confidence"],
            "function": code_context.function_name,
            "class": code_context.class_name,
            "variables": len(code_context.variable_context),
            "analysis_details": relevance["analysis_details"]
        }
        issue_summaries.append(summary)
    
    # 按相关性分数排序
    issue_summaries.sort(key=lambda x: x["relevance_score"], reverse=True)
    
    # 构建AI提示
    system_prompt = (
        "你是C++代码质量专家。任务：从经过上下文分析的问题中选择最有代表性的测试用例。"
        "选择原则：\n"
        "1. 优先选择相关性分数高的问题（已按分数排序）\n"
        "2. 优先选择不同严重级别的问题（error > warning > information）\n"
        "3. 优先选择不同规则ID的问题，避免重复\n"
        "4. 优先选择不同文件的问题，提高覆盖面\n"
        "5. 优先选择有明确函数/类上下文的问题\n"
        "6. 优先选择容易复现和验证的问题\n\n"
        "请只返回选中的问题索引列表，用逗号分隔，不要其他解释。"
    )
    
    user_prompt = (
        f"需要从 {len(real_issues)} 个可能真实存在的问题中选择最多 {max_count} 个最有代表性的测试用例。\n\n"
        f"问题列表（已按相关性分数排序）：\n"
    )
    
    for summary in issue_summaries:
        context_info = []
        if summary["function"]:
            context_info.append(f"函数:{summary['function']}")
        if summary["class"]:
            context_info.append(f"类:{summary['class']}")
        if summary["variables"] > 0:
            context_info.append(f"变量:{summary['variables']}个")
        
        context_str = f" ({', '.join(context_info)})" if context_info else ""
        
        user_prompt += (
            f"索引{summary['index']}: [{summary['severity']}] {summary['id']} "
            f"(分数:{summary['relevance_score']}, 置信度:{summary['confidence']}%) "
            f"- {summary['message'][:80]}... "
            f"(文件: {summary['file']}, 行: {summary['line']}){context_str}\n"
        )
    
    user_prompt += f"\n请选择最有代表性的 {max_count} 个问题，返回索引列表："
    
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": user_prompt},
    ]
    
    resp = client.chat.completions.create(
        model=model,
        messages=messages,
        stream=False,
        temperature=0.1,  # 低温度确保一致性
    )
    
    content = resp.choices[0].message.content if resp.choices else ""
    
    # 解析返回的索引
    selected_indices = []
    try:
        # 提取数字
        import re
        numbers = re.findall(r'\d+', content)
        for num_str in numbers:
            idx = int(num_str)
            if 0 <= idx < len(real_issues):
                selected_indices.append(idx)
        
        # 去重并保持顺序
        selected_indices = list(dict.fromkeys(selected_indices))
        
        # 限制数量
        if len(selected_indices) > max_count:
            selected_indices = selected_indices[:max_count]
            
    except Exception as e:
        print(f"解析AI选择结果失败: {e}")
        print(f"AI返回内容: {content}")
        # 回退到简单选择：按相关性分数排序
        selected_indices = list(range(min(max_count, len(real_issues))))
    
    # 返回选中的问题
    selected_issues = [real_issues[i][0] for i in selected_indices if i < len(real_issues)]
    
    print(f"AI智能选择：从 {len(issues)} 个问题中筛选出 {len(real_issues)} 个可能真实的问题，最终选择了 {len(selected_issues)} 个最有代表性的测试用例")
    return selected_issues


def verify_single_test(cpp_file: Path, timeout: int = 30, project_root: Optional[Path] = None, include_dirs: List[str] = None) -> dict:
    """验证单个测试用例"""
    import subprocess
    import time
    import signal
    import os
    
    result = {
        "file": cpp_file.name,
        "compiled": False,
        "executed": False,
        "exit_code": None,
        "output": "",
        "error": "",
        "duration": 0,
        "timeout": False,
        "vulnerability_confirmed": False,
        "vulnerability_type": "unknown"
    }
    
    exe_file = cpp_file.with_suffix(".exe")
    
    try:
        # 编译
        start_time = time.time()
        compile_cmd = [
            "g++", "-std=c++17", "-O0", "-g", "-Wall", "-Wextra", "-pedantic"
        ]
        
        # 添加项目相关的编译选项
        if project_root:
            compile_cmd.extend(["-I", str(project_root)])
        
        if include_dirs:
            for include_dir in include_dirs:
                compile_cmd.extend(["-I", include_dir])
        
        compile_cmd.extend(["-o", str(exe_file), str(cpp_file)])
        
        compile_result = subprocess.run(
            compile_cmd, 
            capture_output=True, 
            text=True, 
            timeout=timeout
        )
        
        result["compiled"] = (compile_result.returncode == 0)
        result["duration"] = time.time() - start_time
        
        if not result["compiled"]:
            result["error"] = compile_result.stderr
            return result
        
        # 执行
        if exe_file.exists():
            start_time = time.time()
            try:
                execute_result = subprocess.run(
                    [str(exe_file)], 
                    capture_output=True, 
                    text=True, 
                    timeout=timeout
                )
                
                result["executed"] = True
                result["exit_code"] = execute_result.returncode
                result["output"] = execute_result.stdout
                result["error"] = execute_result.stderr
                result["duration"] = time.time() - start_time
                
                # 分析漏洞类型
                result["vulnerability_type"] = analyze_vulnerability_type(cpp_file.name, result)
                result["vulnerability_confirmed"] = determine_vulnerability_confirmed(result)
                
            except subprocess.TimeoutExpired:
                result["timeout"] = True
                result["error"] = f"执行超时（{timeout}秒）"
            except Exception as e:
                result["error"] = f"执行异常: {str(e)}"
    
    except subprocess.TimeoutExpired:
        result["timeout"] = True
        result["error"] = f"编译超时（{timeout}秒）"
    except Exception as e:
        result["error"] = f"编译异常: {str(e)}"
    finally:
        # 清理
        if exe_file.exists():
            exe_file.unlink()
    
    return result


def analyze_vulnerability_type(filename: str, result: dict) -> str:
    """分析漏洞类型"""
    filename_lower = filename.lower()
    
    if "uninitvar" in filename_lower:
        return "未初始化变量"
    elif "memleak" in filename_lower:
        return "内存泄漏"
    elif "nullpointer" in filename_lower:
        return "空指针解引用"
    elif "arrayindex" in filename_lower:
        return "数组越界"
    elif "buffer" in filename_lower:
        return "缓冲区溢出"
    elif "useafterfree" in filename_lower:
        return "释放后使用"
    elif "doublefree" in filename_lower:
        return "重复释放"
    else:
        return "未知类型"


def determine_vulnerability_confirmed(result: dict) -> bool:
    """判断漏洞是否被确认"""
    if not result["compiled"] or not result["executed"]:
        return False
    
    # 根据漏洞类型和程序行为判断
    vuln_type = result["vulnerability_type"]
    exit_code = result["exit_code"]
    output = result["output"]
    error = result["error"]
    
    if "未初始化变量" in vuln_type:
        # 未初始化变量：程序应该能正常运行，但输出随机值
        return exit_code == 0 and "buffer" in output.lower()
    
    elif "内存泄漏" in vuln_type:
        # 内存泄漏：程序应该能正常运行
        return exit_code == 0
    
    elif "空指针解引用" in vuln_type:
        # 空指针解引用：程序应该崩溃
        return exit_code != 0 or "segmentation fault" in error.lower()
    
    elif "数组越界" in vuln_type:
        # 数组越界：程序可能崩溃
        return exit_code != 0 or "segmentation fault" in error.lower()
    
    elif "缓冲区溢出" in vuln_type:
        # 缓冲区溢出：程序可能崩溃
        return exit_code != 0 or "stack smashing" in error.lower()
    
    else:
        # 默认：程序能正常运行就认为漏洞存在
        return exit_code == 0


def verify_test_case(test_file_path: Path, issue: CppcheckIssue) -> dict:
    """验证生成的测试用例是否能有效触发cppcheck检测"""
    verification_result = {
        'compiles': False,
        'runs': False,
        'triggers_cppcheck': False,
        'cppcheck_warnings': [],
        'compilation_errors': [],
        'runtime_errors': []
    }
    
    try:
        # 1. 尝试编译测试用例
        import subprocess
        import tempfile
        import os
        
        # 创建临时目录
        with tempfile.TemporaryDirectory() as temp_dir:
            temp_cpp = Path(temp_dir) / "test.cpp"
            temp_exe = Path(temp_dir) / "test"
            
            # 复制测试文件到临时目录
            with open(test_file_path, 'r', encoding='utf-8') as f:
                test_content = f.read()
            
            with open(temp_cpp, 'w', encoding='utf-8') as f:
                f.write(test_content)
            
            # 尝试编译
            try:
                result = subprocess.run(
                    ['g++', '-std=c++17', '-o', str(temp_exe), str(temp_cpp)],
                    capture_output=True, text=True, timeout=30
                )
                
                if result.returncode == 0:
                    verification_result['compiles'] = True
                    
                    # 2. 尝试运行
                    try:
                        run_result = subprocess.run(
                            [str(temp_exe)],
                            capture_output=True, text=True, timeout=10
                        )
                        if run_result.returncode == 0:
                            verification_result['runs'] = True
                        else:
                            verification_result['runtime_errors'].append(run_result.stderr)
                    except subprocess.TimeoutExpired:
                        verification_result['runtime_errors'].append("Runtime timeout")
                    except Exception as e:
                        verification_result['runtime_errors'].append(str(e))
                else:
                    verification_result['compilation_errors'].append(result.stderr)
                    
            except subprocess.TimeoutExpired:
                verification_result['compilation_errors'].append("Compilation timeout")
            except Exception as e:
                verification_result['compilation_errors'].append(str(e))
            
            # 3. 使用cppcheck检查
            try:
                cppcheck_result = subprocess.run(
                    ['cppcheck', '--enable=all', '--std=c++17', str(temp_cpp)],
                    capture_output=True, text=True, timeout=30
                )
                
                if cppcheck_result.returncode != 0 or cppcheck_result.stderr:
                    # 解析cppcheck输出
                    output = cppcheck_result.stderr
                    if issue.id.lower() in output.lower():
                        verification_result['triggers_cppcheck'] = True
                    
                    # 提取警告信息
                    lines = output.split('\n')
                    for line in lines:
                        if 'warning:' in line or 'error:' in line:
                            verification_result['cppcheck_warnings'].append(line.strip())
                            
            except subprocess.TimeoutExpired:
                verification_result['cppcheck_warnings'].append("cppcheck timeout")
            except Exception as e:
                verification_result['cppcheck_warnings'].append(f"cppcheck error: {str(e)}")
                
    except Exception as e:
        verification_result['compilation_errors'].append(f"Verification error: {str(e)}")
    
    return verification_result

def write_issue_output(output_dir: Path, idx: int, issue: CppcheckIssue, content: str, emit_runner: bool = False, verify: bool = False) -> Path:
    output_dir.mkdir(parents=True, exist_ok=True)

    # 提取 ```cpp ... ``` 代码块（仅取第一个）
    cpp_code: Optional[str] = None
    lines = content.splitlines()
    inside = False
    fence = None
    buf: List[str] = []
    for line in lines:
        if not inside:
            if line.strip().startswith("```cpp") or line.strip().startswith("```c++"):
                inside = True
                fence = line[:3]
                buf = []
        else:
            if line.strip().startswith("```"):
                inside = False
                cpp_code = "\n".join(buf).strip()
                break
            else:
                buf.append(line)

    # 写 Markdown 说明
    md_path = output_dir / f"issue_{idx:03d}_{issue.id}.md"
    md_path.write_text(content, encoding="utf-8")

    # 若提取到 C++ 代码，则写出 .cpp 文件，并可选生成 PowerShell 一键运行脚本
    if cpp_code:
        base = f"issue_{idx:03d}_{issue.id}"
        cpp_path = output_dir / f"{base}.cpp"
        cpp_path.write_text(cpp_code, encoding="utf-8")

        # 验证测试用例（如果启用）
        if verify:
            print(f"  正在验证测试用例...")
            verification_result = verify_test_case(cpp_path, issue)
            
            # 输出验证结果
            if verification_result['compiles']:
                print(f"    ✓ 编译成功")
            else:
                print(f"    ✗ 编译失败: {verification_result['compilation_errors']}")
            
            if verification_result['runs']:
                print(f"    ✓ 运行成功")
            else:
                print(f"    ✗ 运行失败: {verification_result['runtime_errors']}")
            
            if verification_result['triggers_cppcheck']:
                print(f"    ✓ 成功触发cppcheck检测")
            else:
                print(f"    ✗ 未触发cppcheck检测")
                if verification_result['cppcheck_warnings']:
                    print(f"    cppcheck输出: {verification_result['cppcheck_warnings']}")
            
            # 保存验证结果到文件
            verification_file = output_dir / f"verification_{idx:03d}_{issue.id}.json"
            import json
            with open(verification_file, 'w', encoding='utf-8') as f:
                json.dump(verification_result, f, ensure_ascii=False, indent=2)

        if emit_runner:
            ps1 = output_dir / f"run_{base}.ps1"
            exe = output_dir / f"{base}.exe"
            cmd = (
                f"g++ -std=c++17 -O0 -g -Wall -Wextra -pedantic -o \"{exe.name}\" \"{cpp_path.name}\"\n"
                f"if ($LASTEXITCODE -ne 0) {{ Write-Host '编译失败' -ForegroundColor Red; exit 1 }}\n"
                f"./{exe.name}\n"
            )
            ps1.write_text(cmd, encoding="utf-8")
    return md_path


def auto_verify_tests(output_dir: Path, timeout: int = 30, project_root: Optional[Path] = None, include_dirs: List[str] = None) -> dict:
    """自动验证所有测试用例"""
    print("开始自动验证测试用例...")
    
    cpp_files = list(output_dir.glob("*.cpp"))
    if not cpp_files:
        print("未找到测试用例文件")
        return {"total": 0, "results": [], "summary": {}}
    
    results = []
    for i, cpp_file in enumerate(cpp_files, 1):
        print(f"验证 [{i}/{len(cpp_files)}]: {cpp_file.name}")
        result = verify_single_test(cpp_file, timeout, project_root, include_dirs)
        results.append(result)
        
        # 显示验证结果
        if result["vulnerability_confirmed"]:
            print(f"  ✓ 漏洞确认: {result['vulnerability_type']}")
        elif result["compiled"] and result["executed"]:
            print(f"  - 程序正常: {result['vulnerability_type']} (可能误报)")
        else:
            print(f"  ✗ 验证失败: {result['error']}")
    
    # 生成汇总统计
    summary = {
        "total": len(results),
        "compiled": sum(1 for r in results if r["compiled"]),
        "executed": sum(1 for r in results if r["executed"]),
        "vulnerabilities_confirmed": sum(1 for r in results if r["vulnerability_confirmed"]),
        "timeouts": sum(1 for r in results if r["timeout"]),
        "errors": sum(1 for r in results if not r["compiled"] or not r["executed"])
    }
    
    return {"total": len(results), "results": results, "summary": summary}


def generate_verification_report(output_dir: Path, verification_results: dict) -> Path:
    """生成验证结果报告"""
    report_path = output_dir / "vulnerability_verification_report.md"
    
    results = verification_results["results"]
    summary = verification_results["summary"]
    
    # 按漏洞类型分组
    vuln_groups = {}
    for result in results:
        vuln_type = result["vulnerability_type"]
        if vuln_type not in vuln_groups:
            vuln_groups[vuln_type] = []
        vuln_groups[vuln_type].append(result)
    
    # 生成报告内容
    report_content = f"""# 漏洞验证结果报告

## 验证汇总

- **总测试用例**: {summary['total']}
- **编译成功**: {summary['compiled']}
- **执行成功**: {summary['executed']}
- **漏洞确认**: {summary['vulnerabilities_confirmed']}
- **验证超时**: {summary['timeouts']}
- **验证错误**: {summary['errors']}

## 漏洞确认列表

"""
    
    # 按漏洞类型生成详细报告
    for vuln_type, vuln_results in vuln_groups.items():
        confirmed_count = sum(1 for r in vuln_results if r["vulnerability_confirmed"])
        total_count = len(vuln_results)
        
        report_content += f"### {vuln_type} ({confirmed_count}/{total_count} 确认)\n\n"
        
        for result in vuln_results:
            status = "✓ 确认" if result["vulnerability_confirmed"] else "✗ 未确认"
            report_content += f"- **{result['file']}**: {status}\n"
            
            if result["vulnerability_confirmed"]:
                report_content += f"  - 返回码: {result['exit_code']}\n"
                if result["output"]:
                    report_content += f"  - 输出: {result['output'][:100]}...\n"
            elif result["error"]:
                report_content += f"  - 错误: {result['error']}\n"
            
            report_content += "\n"
    
    # 添加修复建议
    report_content += """## 修复建议

### 确认的漏洞
以下漏洞已被验证确认，建议优先修复：

"""
    
    for vuln_type, vuln_results in vuln_groups.items():
        confirmed_results = [r for r in vuln_results if r["vulnerability_confirmed"]]
        if confirmed_results:
            report_content += f"#### {vuln_type}\n"
            for result in confirmed_results:
                report_content += f"- {result['file']}: 需要修复\n"
            report_content += "\n"
    
    report_content += """### 未确认的问题
以下问题可能是误报或需要进一步分析：

"""
    
    for vuln_type, vuln_results in vuln_groups.items():
        unconfirmed_results = [r for r in vuln_results if not r["vulnerability_confirmed"]]
        if unconfirmed_results:
            report_content += f"#### {vuln_type}\n"
            for result in unconfirmed_results:
                report_content += f"- {result['file']}: 需要进一步分析\n"
            report_content += "\n"
    
    # 写入报告文件
    report_path.write_text(report_content, encoding="utf-8")
    return report_path


def generate_json_report(output_dir: Path, verification_results: dict) -> Path:
    """生成JSON格式的详细报告"""
    import json
    
    json_path = output_dir / "verification_results.json"
    
    # 添加时间戳
    verification_results["timestamp"] = str(Path().cwd())
    verification_results["generated_at"] = str(Path().cwd())
    
    # 写入JSON文件
    json_path.write_text(json.dumps(verification_results, indent=2, ensure_ascii=False), encoding="utf-8")
    return json_path


def filter_and_clean_issues(issues: List[CppcheckIssue], project_info: Optional[dict] = None) -> List[CppcheckIssue]:
    """过滤和清理问题，移除不可靠的问题"""
    print("正在过滤和清理问题...")
    
    cleaned_issues = []
    filtered_count = 0
    
    for issue in issues:
        # 获取增强分析
        code_context, relevance_analysis = get_enhanced_issue_analysis(issue, project_info)
        
        # 基于分析结果决定是否保留问题
        should_keep = False
        
        # 1. 检查相关性分数
        if relevance_analysis["relevance_score"] >= 5:
            should_keep = True
        
        # 2. 检查问题类型 - 排除明显误报
        issue_id = issue.id.lower()
        if issue_id in ["missinginclude", "missingincludesystem", "toomanyconfigs", 
                       "normalchecklevelmaxbranches", "checklevelnormal", "unknown"]:
            should_keep = False
        
        # 3. 检查严重级别 - 优先保留error和warning
        if issue.severity.lower() in ["error", "warning"]:
            should_keep = True
        elif issue.severity.lower() in ["information", "note"]:
            # 对于information和note，需要更高的相关性分数
            if relevance_analysis["relevance_score"] >= 7:
                should_keep = True
        
        # 4. 检查是否有代码上下文
        if code_context.function_name or code_context.class_name:
            should_keep = True
        
        if should_keep:
            cleaned_issues.append(issue)
        else:
            filtered_count += 1
            print(f"  过滤问题: {issue.id} - {issue.message[:50]}... (相关性分数: {relevance_analysis['relevance_score']})")
    
    print(f"问题过滤完成: 保留 {len(cleaned_issues)} 个问题，过滤掉 {filtered_count} 个不可靠问题")
    return cleaned_issues


def write_cleaned_report(issues: List[CppcheckIssue], output_path: Path) -> None:
    """将清理后的问题写入新的报告文件"""
    print(f"正在生成清理后的报告: {output_path}")
    
    with open(output_path, 'w', encoding='utf-8') as f:
        for issue in issues:
            for location in issue.locations:
                f.write(f"{location.file_path}:{location.line}:0: {issue.severity}: {issue.message} [{issue.id}]\n")
    
    print(f"清理后的报告已保存: {output_path}")


def main(argv: list[str]) -> int:
    parser = argparse.ArgumentParser(description="根据 cppcheck XML 与源码生成可运行的 C++ 复现用例")
    parser.add_argument("report", help="cppcheck 报告路径：支持 XML（--xml）或文本日志（自动识别或 --text）")
    parser.add_argument("--out", default="cppcheck_tests", help="输出目录，默认 cppcheck_tests")
    parser.add_argument("--model", default="deepseek-chat", help="模型名称，默认 deepseek-chat")
    parser.add_argument("--emit-runner", action="store_true", help="为每个用例生成一键编译运行的 PowerShell 脚本")
    parser.add_argument("--text", action="store_true", help="强制按文本日志格式解析")
    parser.add_argument("--xml", action="store_true", help="强制按 XML 格式解析")
    parser.add_argument("--max", type=int, default=10, help="最多处理前 N 条问题（默认 10，设为 0 表示不限）")
    parser.add_argument(
        "--severities",
        default="warning,error",
        help="过滤等级，逗号分隔（如 warning,error,information,note；默认 warning,error）",
    )
    parser.add_argument(
        "--include-ids",
        default="",
        help="仅包含这些 ruleId（逗号分隔，留空表示不限）",
    )
    parser.add_argument(
        "--exclude-ids",
        default="missingInclude,missingIncludeSystem,toomanyconfigs,normalCheckLevelMaxBranches,checkLevelNormal,unknown",
        help="排除这些 ruleId（逗号分隔，默认排除若干低价值项）",
    )
    parser.add_argument(
        "--smart-select",
        action="store_true",
        help="使用AI智能选择最有代表性的测试用例（推荐用于大量问题）",
    )
    parser.add_argument(
        "--smart-max",
        type=int,
        default=10,
        help="智能选择模式下的最大测试用例数量（默认10）",
    )
    parser.add_argument(
        "--auto-verify",
        action="store_true",
        help="生成测试用例后自动运行验证并生成结果报告",
    )
    parser.add_argument(
        "--verify-timeout",
        type=int,
        default=30,
        help="验证超时时间（秒，默认30）",
    )
    parser.add_argument(
        "--verify-tests",
        action="store_true",
        help="生成测试用例时立即验证每个测试用例的有效性",
    )
    parser.add_argument(
        "--use-templates",
        action="store_true",
        help="使用预定义的测试用例模板，确保能有效触发cppcheck检测",
    )
    parser.add_argument(
        "--project-root",
        help="原始项目根目录路径（用于包含头文件和依赖）",
    )
    parser.add_argument(
        "--include-dirs",
        help="额外的头文件包含目录（逗号分隔）",
    )
    parser.add_argument(
        "--integration-test",
        action="store_true",
        help="生成集成测试用例（需要原始项目）",
    )
    parser.add_argument(
        "--enhanced-analysis",
        action="store_true",
        help="启用增强分析模式，基于代码上下文和项目结构进行智能筛选",
    )
    parser.add_argument(
        "--clean-report",
        action="store_true",
        help="生成清理后的cppcheck报告文件，过滤掉不可靠的问题",
    )
    parser.add_argument(
        "--cleaned-report",
        help="使用已清理的报告文件（跳过问题过滤步骤）",
    )
    args = parser.parse_args(argv)

    # 处理报告文件路径
    if args.cleaned_report:
        # 使用已清理的报告文件
        report_path = Path(args.cleaned_report).expanduser().resolve()
        if not report_path.exists():
            raise SystemExit(f"找不到已清理的报告文件: {report_path}")
        print(f"使用已清理的报告文件: {report_path}")
    else:
        # 使用原始报告文件
        report_path = Path(args.report).expanduser().resolve()
        if not report_path.exists():
            raise SystemExit(f"找不到报告文件: {report_path}")

    # 解析报告文件
    issues: List[CppcheckIssue] = []
    if args.xml or (report_path.suffix.lower() in {".xml"} and not args.text):
        issues = parse_cppcheck_xml(report_path)
    else:
        issues = parse_cppcheck_text(report_path)

    print(f"原始报告包含 {len(issues)} 个问题")

    # 基本过滤：按严重级别、包含/排除的 ruleId、去重
    sev_set: Set[str] = {s.strip().lower() for s in (args.severities or "").split(",") if s.strip()}
    include_ids: Set[str] = {s.strip() for s in (args.include_ids or "").split(",") if s.strip()}
    exclude_ids: Set[str] = {s.strip() for s in (args.exclude_ids or "").split(",") if s.strip()}

    filtered: List[CppcheckIssue] = []
    seen: Set[tuple] = set()
    for iss in issues:
        if sev_set and iss.severity and iss.severity.lower() not in sev_set:
            continue
        if include_ids and iss.id not in include_ids:
            continue
        if exclude_ids and iss.id in exclude_ids:
            continue
        # 以 (id, first_file, first_line) 去重
        key = (iss.id, str(iss.locations[0].file_path) if iss.locations else "", iss.locations[0].line if iss.locations else None)
        if key in seen:
            continue
        seen.add(key)
        filtered.append(iss)

    print(f"基本过滤后剩余 {len(filtered)} 个问题")

    if not filtered:
        print("未在报告中发现问题项。")
        return 0

    # 处理项目上下文
    project_root = None
    include_dirs = []
    project_info = None
    
    if args.project_root:
        project_root = Path(args.project_root).expanduser().resolve()
        if not project_root.exists():
            print(f"警告: 项目根目录不存在: {project_root}")
            project_root = None
        else:
            print("正在分析项目结构...")
            project_info = analyze_project_structure(project_root)
            print(f"项目分析完成: 发现 {len(project_info['source_files'])} 个源文件, {len(project_info['header_files'])} 个头文件")
    
    if args.include_dirs:
        include_dirs = [d.strip() for d in args.include_dirs.split(",") if d.strip()]
        valid_include_dirs = []
        for include_dir in include_dirs:
            include_path = Path(include_dir).expanduser().resolve()
            if include_path.exists():
                valid_include_dirs.append(str(include_path))
            else:
                print(f"警告: 头文件目录不存在: {include_path}")
        include_dirs = valid_include_dirs

    # 问题过滤和清理
    if args.clean_report and not args.cleaned_report:
        print("\n" + "="*50)
        print("开始问题过滤和清理...")
        print("="*50)
        
        cleaned_issues = filter_and_clean_issues(filtered, project_info)
        
        # 生成清理后的报告文件
        cleaned_report_path = Path(args.out) / "cleaned_cppcheck_report.txt"
        write_cleaned_report(cleaned_issues, cleaned_report_path)
        
        print(f"\n清理完成！")
        print(f"原始问题数量: {len(issues)}")
        print(f"基本过滤后: {len(filtered)}")
        print(f"智能清理后: {len(cleaned_issues)}")
        print(f"清理后的报告已保存: {cleaned_report_path}")
        
        # 使用清理后的问题继续处理
        filtered = cleaned_issues
    elif args.enhanced_analysis:
        # 使用增强分析进行智能筛选
        print("\n" + "="*50)
        print("开始增强分析...")
        print("="*50)
        
        cleaned_issues = filter_and_clean_issues(filtered, project_info)
        filtered = cleaned_issues

    # 智能选择模式
    if args.smart_select or args.enhanced_analysis:
        if args.enhanced_analysis:
            print(f"启用增强分析模式，从 {len(filtered)} 个问题中选择最多 {args.smart_max} 个最有代表性的测试用例...")
        else:
            print(f"启用AI智能选择模式，从 {len(filtered)} 个问题中选择最多 {args.smart_max} 个最有代表性的测试用例...")
        issues = smart_select_issues(filtered, args.smart_max, args.model)
    else:
        # 传统模式：简单限制数量
        if args.max and args.max > 0:
            issues = filtered[: args.max]
        else:
            issues = filtered

    output_dir = Path(args.out).expanduser().resolve()

    # 为每个问题生成增强的测试用例
    for idx, issue in enumerate(issues, start=1):
        print(f"生成测试用例 {idx}/{len(issues)}: {issue.id}")
        
        # 获取增强的问题分析
        code_context, relevance_analysis = get_enhanced_issue_analysis(issue, project_info)
        
        # 显示分析结果
        print(f"  相关性分数: {relevance_analysis['relevance_score']}, 置信度: {relevance_analysis['confidence']}%")
        if code_context.function_name:
            print(f"  所在函数: {code_context.function_name}")
        if code_context.class_name:
            print(f"  所在类: {code_context.class_name}")
        
        # 使用AI生成模式（这是核心功能）
        content = generate_test_for_issue(
            issue, 
            model=args.model, 
            project_root=project_root, 
            include_dirs=include_dirs, 
            integration_test=args.integration_test,
            code_context=code_context,
            relevance_analysis=relevance_analysis
        )
        out_path = write_issue_output(output_dir, idx, issue, content, emit_runner=args.emit_runner, verify=args.verify_tests)
        print(f"  已生成: {out_path}")

    print(f"完成，共生成 {len(issues)} 条用例说明。")
    
    # 自动验证
    if args.auto_verify:
        print("\n" + "="*50)
        print("开始自动验证测试用例...")
        print("="*50)
        
        verification_results = auto_verify_tests(output_dir, args.verify_timeout, project_root, include_dirs)
        
        # 生成报告
        print("\n生成验证报告...")
        md_report = generate_verification_report(output_dir, verification_results)
        json_report = generate_json_report(output_dir, verification_results)
        
        print(f"Markdown报告: {md_report}")
        print(f"JSON报告: {json_report}")
        
        # 显示汇总
        summary = verification_results["summary"]
        print(f"\n验证汇总:")
        print(f"  总测试用例: {summary['total']}")
        print(f"  编译成功: {summary['compiled']}")
        print(f"  执行成功: {summary['executed']}")
        print(f"  漏洞确认: {summary['vulnerabilities_confirmed']}")
        print(f"  验证超时: {summary['timeouts']}")
        print(f"  验证错误: {summary['errors']}")
        
        # 显示确认的漏洞
        confirmed_vulns = [r for r in verification_results["results"] if r["vulnerability_confirmed"]]
        if confirmed_vulns:
            print(f"\n确认的漏洞 ({len(confirmed_vulns)} 个):")
            for result in confirmed_vulns:
                print(f"  ✓ {result['file']}: {result['vulnerability_type']}")
        else:
            print("\n未确认任何漏洞")
    
    return 0


if __name__ == "__main__":
    raise SystemExit(main(sys.argv[1:]))