const fs = require('fs');
const path = require('path');
const https = require('https');
const http = require('http');
const crypto = require('crypto');

/**
 * AI分析服务
 * 用于对代码检查结果进行智能分析、去重、风险评估和生成修改建议
 * 支持OpenAI和科大讯飞Spark API
 */
class AIAnalyzer {
    constructor() {
        // OpenAI配置
        this.openaiApiKey = process.env.OPENAI_API_KEY || '';
        this.openaiApiBase = process.env.OPENAI_API_BASE || 'https://api.openai.com/v1';
        this.openaiModel = process.env.OPENAI_MODEL || 'gpt-3.5-turbo';
        
        // 科大讯飞配置（HTTP API）
        // 注意：HTTP API使用APIpassword（Bearer Token），不是apikey和apisecret
        // 获取地址：https://console.xfyun.cn/services/bmx1
        this.xfApiPassword = process.env.XF_API_PASSWORD || process.env.XF_API_KEY || ''; // HTTP协议的APIpassword
        this.xfApiKey = process.env.XF_API_KEY || ''; // 兼容旧配置
        this.xfApiSecret = process.env.XF_API_SECRET || ''; // 兼容旧配置（WebSocket使用）
        this.xfModel = process.env.XF_MODEL || 'spark-x'; // Spark X1.5 模型，使用spark-x
        this.xfApiUrl = process.env.XF_API_URL || 'https://spark-api-open.xf-yun.com/v2/chat/completions';
        
        // 选择使用的API提供商
        this.provider = process.env.AI_PROVIDER || 'xf'; // 'openai' 或 'xf'
        this.enabled = process.env.AI_ANALYZER_ENABLED !== 'false';
        
        console.log(`[AI分析] 使用提供商: ${this.provider}`);
        if (this.provider === 'xf') {
            if (this.xfApiPassword) {
                console.log(`[AI分析] 科大讯飞 HTTP API Password: ${this.xfApiPassword.substring(0, 10)}... (已配置)`);
                console.log(`[AI分析] 使用模型: ${this.xfModel}`);
            } else {
                console.log(`[AI分析] 科大讯飞 HTTP API Password: 未配置`);
                console.log(`[AI分析] 请在控制台获取APIpassword: https://console.xfyun.cn/services/bmx1`);
            }
        } else if (this.provider === 'openai') {
            console.log(`[AI分析] OpenAI API Key: ${this.openaiApiKey ? '已配置' : '未配置'}`);
        }
    }

    /**
     * 分析检查结果
     * @param {Array} issues - 检查结果列表
     * @param {string} projectPath - 项目路径
     * @returns {Promise<Object>} 分析结果
     */
    async analyzeIssues(issues, projectPath = null) {
        if (!this.enabled) {
            console.log('[AI分析] AI分析功能已禁用，使用基础去重');
            return this.basicDeduplication(issues);
        }

        try {
            // 先进行基础去重
            const deduplicated = this.basicDeduplication(issues);
            
            // 检查是否有可用的API配置
            const hasApiConfig = (this.provider === 'openai' && this.openaiApiKey) || 
                                (this.provider === 'xf' && this.xfApiPassword);
            
            if (hasApiConfig) {
                return await this.aiAnalysis(deduplicated.issues, projectPath);
            } else {
                // 否则使用规则基础分析
                console.log('[AI分析] 未配置API密钥，使用规则基础分析');
                return this.ruleBasedAnalysis(deduplicated.issues);
            }
        } catch (error) {
            console.error('[AI分析] 分析失败，回退到基础分析:', error);
            return this.basicDeduplication(issues);
        }
    }

    /**
     * 基础去重 - 基于文件、行号、规则和消息相似度
     */
    basicDeduplication(issues) {
        const seen = new Map();
        const uniqueIssues = [];
        const duplicates = [];

        for (const issue of issues) {
            // 生成唯一键：文件路径 + 行号 + 规则ID
            const key = `${issue.relative_path || issue.file}:${issue.line}:${issue.rule || 'unknown'}`;
            
            if (seen.has(key)) {
                // 检查消息相似度
                const existing = seen.get(key);
                const similarity = this.calculateSimilarity(
                    issue.message || '',
                    existing.message || ''
                );
                
                if (similarity < 0.7) {
                    // 消息差异较大，可能是不同的问题
                    uniqueIssues.push(issue);
                } else {
                    // 相似度高，合并工具来源
                    if (!existing.detected_by) {
                        existing.detected_by = [existing.tool || 'unknown'];
                    }
                    if (issue.tool && !existing.detected_by.includes(issue.tool)) {
                        existing.detected_by.push(issue.tool);
                    }
                    duplicates.push(issue);
                }
            } else {
                issue.detected_by = issue.tool ? [issue.tool] : ['unknown'];
                seen.set(key, issue);
                uniqueIssues.push(issue);
            }
        }

        return {
            issues: uniqueIssues,
            total_issues: uniqueIssues.length,
            duplicates_removed: duplicates.length,
            deduplication_rate: issues.length > 0 
                ? ((duplicates.length / issues.length) * 100).toFixed(2) + '%'
                : '0%'
        };
    }

    /**
     * 计算字符串相似度（简单的Jaccard相似度）
     */
    calculateSimilarity(str1, str2) {
        if (!str1 || !str2) return 0;
        const words1 = new Set(str1.toLowerCase().split(/\s+/));
        const words2 = new Set(str2.toLowerCase().split(/\s+/));
        const intersection = new Set([...words1].filter(x => words2.has(x)));
        const union = new Set([...words1, ...words2]);
        return intersection.size / union.size;
    }

    /**
     * 基于规则的分析（不使用AI）
     */
    ruleBasedAnalysis(issues) {
        const analyzed = issues.map(issue => {
            const risk = this.assessRisk(issue);
            const suggestion = this.generateSuggestion(issue);
            
            return {
                ...issue,
                risk_level: risk.level,
                risk_score: risk.score,
                suggestion: suggestion,
                ai_analyzed: false
            };
        });

        // 按风险评分排序
        analyzed.sort((a, b) => b.risk_score - a.risk_score);

        return {
            issues: analyzed,
            total_issues: analyzed.length,
            high_risk_count: analyzed.filter(i => i.risk_level === 'high').length,
            medium_risk_count: analyzed.filter(i => i.risk_level === 'medium').length,
            low_risk_count: analyzed.filter(i => i.risk_level === 'low').length,
            analysis_method: 'rule-based'
        };
    }

    /**
     * 使用AI进行分析
     */
    async aiAnalysis(issues, projectPath) {
        try {
            // 一次性发送所有问题，不再分批处理
            console.log(`[AI分析] 开始AI分析，共 ${issues.length} 个问题，一次性处理`);
            
            const analyzedIssues = this.provider === 'xf' 
                ? await this.analyzeBatchXf(issues, projectPath)
                : await this.analyzeBatch(issues, projectPath);

            // 按风险评分排序
            analyzedIssues.sort((a, b) => b.risk_score - a.risk_score);

            return {
                issues: analyzedIssues,
                total_issues: analyzedIssues.length,
                high_risk_count: analyzedIssues.filter(i => i.risk_level === 'high').length,
                medium_risk_count: analyzedIssues.filter(i => i.risk_level === 'medium').length,
                low_risk_count: analyzedIssues.filter(i => i.risk_level === 'low').length,
                analysis_method: 'ai-powered'
            };
        } catch (error) {
            console.error('[AI分析] AI分析失败:', error);
            // 回退到规则基础分析
            return this.ruleBasedAnalysis(issues);
        }
    }

    /**
     * 批量分析问题
     */
    async analyzeBatch(issues, projectPath) {
        const prompt = await this.buildAnalysisPrompt(issues, projectPath);
        
        try {
            const requestData = JSON.stringify({
                model: this.openaiModel,
                messages: [
                    {
                        role: 'system',
                        content: '你是一个专业的Python代码质量分析专家，擅长分析代码问题，评估风险并提供详细、具体的修改建议。你的建议必须包含问题分析、修复步骤、代码示例和最佳实践。'
                    },
                    {
                        role: 'user',
                        content: prompt
                    }
                ],
                temperature: 0.3,
                max_tokens: 8000  // 增加token数量以支持一次性处理所有问题和完整代码
            });

            const url = new URL(`${this.openaiApiBase}/chat/completions`);
            const options = {
                hostname: url.hostname,
                port: url.port || (url.protocol === 'https:' ? 443 : 80),
                path: url.pathname,
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${this.openaiApiKey}`,
                    'Content-Length': Buffer.byteLength(requestData)
                }
            };

            const data = await new Promise((resolve, reject) => {
                const client = url.protocol === 'https:' ? https : http;
                const req = client.request(options, (res) => {
                    let responseData = '';
                    res.on('data', (chunk) => {
                        responseData += chunk;
                    });
                    res.on('end', () => {
                        if (res.statusCode !== 200) {
                            reject(new Error(`AI API错误: ${res.statusCode} ${res.statusMessage}`));
                            return;
                        }
                        try {
                            resolve(JSON.parse(responseData));
                        } catch (e) {
                            reject(new Error(`解析AI响应失败: ${e.message}`));
                        }
                    });
                });
                req.on('error', reject);
                req.write(requestData);
                req.end();
            });

            // 提取AI返回的内容
            let aiContent = '';
            if (data.choices && data.choices.length > 0) {
                aiContent = data.choices[0].message.content || '';
            } else if (data.content) {
                aiContent = data.content;
            } else {
                throw new Error('AI响应中未找到内容');
            }

            console.log(`[AI分析-OpenAI] 收到响应，长度: ${aiContent.length} 字符`);
            console.log(`[AI分析-OpenAI] 响应内容预览: ${aiContent.substring(0, 300)}`);
            
            // 解析AI响应中的JSON
            let analysisResult;
            try {
                // 尝试直接解析
                analysisResult = JSON.parse(aiContent);
            } catch (e) {
                // 如果不是纯JSON，尝试提取JSON部分
                console.log('[AI分析-OpenAI] 直接解析失败，尝试提取JSON部分');
                const jsonMatch = aiContent.match(/\{[\s\S]*\}/);
                if (jsonMatch) {
                    try {
                        analysisResult = JSON.parse(jsonMatch[0]);
                        console.log('[AI分析-OpenAI] 成功提取并解析JSON');
                    } catch (e2) {
                        console.error('[AI分析-OpenAI] 提取的JSON解析失败:', e2);
                        console.error('[AI分析-OpenAI] 响应内容:', aiContent.substring(0, 1000));
                        throw new Error('无法解析AI响应为JSON: ' + e2.message);
                    }
                } else {
                    console.error('[AI分析-OpenAI] 响应中未找到JSON格式');
                    console.error('[AI分析-OpenAI] 响应内容:', aiContent.substring(0, 1000));
                    throw new Error('AI响应中未找到有效的JSON格式');
                }
            }
            
            // 验证分析结果格式
            if (!analysisResult.issues || !Array.isArray(analysisResult.issues)) {
                console.warn('[AI分析-OpenAI] AI返回的格式不正确，使用规则基础分析');
                console.warn('[AI分析-OpenAI] 返回的数据结构:', JSON.stringify(analysisResult).substring(0, 500));
                throw new Error('AI返回格式不正确');
            }
            
            console.log(`[AI分析-OpenAI] 成功解析，包含 ${analysisResult.issues.length} 个问题的分析结果`);
            
            // 合并分析结果到原始问题
            return issues.map((issue, index) => {
                const analysis = analysisResult.issues && analysisResult.issues[index] ? analysisResult.issues[index] : {};
                const aiSuggestion = analysis.suggestion || '';
                
                // 验证AI返回的建议是否有效
                if (!aiSuggestion || aiSuggestion.trim().length < 20) {
                    console.warn(`[AI分析-OpenAI] 问题 ${index + 1} 的AI建议过短或为空，使用规则基础建议`);
                    console.warn(`[AI分析-OpenAI] 原始建议: ${aiSuggestion}`);
                } else {
                    console.log(`[AI分析-OpenAI] 问题 ${index + 1} 获得AI建议，长度: ${aiSuggestion.length} 字符`);
                }
                
                return {
                    ...issue,
                    risk_level: analysis.risk_level || this.assessRisk(issue).level,
                    risk_score: analysis.risk_score !== undefined ? analysis.risk_score : this.assessRisk(issue).score,
                    suggestion: (aiSuggestion && aiSuggestion.trim().length >= 20) ? aiSuggestion : this.generateSuggestion(issue),
                    ai_analyzed: (aiSuggestion && aiSuggestion.trim().length >= 20)
                };
            });
        } catch (error) {
            console.error('[AI分析] 批量分析失败:', error);
            // 回退到规则基础分析
            return issues.map(issue => {
                const risk = this.assessRisk(issue);
                const suggestion = this.generateSuggestion(issue);
                return {
                    ...issue,
                    risk_level: risk.level,
                    risk_score: risk.score,
                    suggestion: suggestion,
                    ai_analyzed: false
                };
            });
        }
    }


    /**
     * 使用科大讯飞API批量分析问题（HTTP方式）
     */
    async analyzeBatchXf(issues, projectPath) {
        const prompt = await this.buildAnalysisPrompt(issues, projectPath);
        
        try {
            // 构建请求数据 - 使用类似OpenAI的格式
            const requestData = JSON.stringify({
                model: this.xfModel,
                messages: [
                    {
                        role: 'system',
                        content: '你是一个专业的Python代码质量分析专家，擅长分析代码问题，评估风险并提供详细、具体的修改建议。你的建议必须包含问题分析、修复步骤、代码示例和最佳实践。'
                    },
                    {
                        role: 'user',
                        content: prompt
                    }
                ],
                temperature: 0.3,
                max_tokens: 8000  // 增加token数量以支持一次性处理所有问题和完整代码
            });

            // 解析API URL
            const url = new URL(this.xfApiUrl);
            
            // 根据官方文档，HTTP API使用Bearer Token认证（APIpassword）
            // 文档：https://www.xfyun.cn/doc/spark/X1http.html
            if (!this.xfApiPassword) {
                throw new Error('未配置XF_API_PASSWORD（HTTP协议的APIpassword），请在控制台获取：https://console.xfyun.cn/services/bmx1');
            }
            
            const options = {
                hostname: url.hostname,
                port: url.port || 443,
                path: url.pathname,
                method: 'POST',
                headers: {
                    'Authorization': `Bearer ${this.xfApiPassword}`,  // 使用Bearer Token
                    'Content-Type': 'application/json',
                    'Content-Length': Buffer.byteLength(requestData)
                }
            };

            console.log(`[AI分析-讯飞] 发送HTTP请求到: ${this.xfApiUrl}`);
            console.log(`[AI分析-讯飞] 使用模型: ${this.xfModel}`);
            console.log(`[AI分析-讯飞] 请求头部:`);
            console.log(`  Authorization: Bearer ${this.xfApiPassword.substring(0, 10)}...`);
            console.log(`  Content-Type: application/json`);
            console.log(`  Content-Length: ${Buffer.byteLength(requestData)}`);

            const data = await new Promise((resolve, reject) => {
                const req = https.request(options, (res) => {
                    let responseData = '';
                    res.on('data', (chunk) => {
                        responseData += chunk;
                    });
                    res.on('end', () => {
                        if (res.statusCode !== 200) {
                            console.error(`[AI分析-讯飞] HTTP错误: ${res.statusCode} ${res.statusMessage}`);
                            console.error(`[AI分析-讯飞] 响应内容:`, responseData.substring(0, 500));
                            reject(new Error(`科大讯飞API错误: ${res.statusCode} ${res.statusMessage}`));
                            return;
                        }
                        try {
                            resolve(JSON.parse(responseData));
                        } catch (e) {
                            console.error('[AI分析-讯飞] 解析响应失败:', e);
                            console.error('[AI分析-讯飞] 响应内容:', responseData.substring(0, 500));
                            reject(new Error(`解析AI响应失败: ${e.message}`));
                        }
                    });
                });
                req.on('error', (error) => {
                    console.error('[AI分析-讯飞] 请求错误:', error);
                    reject(error);
                });
                req.write(requestData);
                req.end();
            });

            // 提取AI返回的内容
            let aiContent = '';
            if (data.choices && data.choices.length > 0) {
                aiContent = data.choices[0].message.content || '';
            } else if (data.content) {
                aiContent = data.content;
            } else {
                throw new Error('AI响应中未找到内容');
            }

            console.log(`[AI分析-讯飞] 收到响应，长度: ${aiContent.length} 字符`);
            console.log(`[AI分析-讯飞] 响应内容预览: ${aiContent.substring(0, 500)}`);
            
            // 如果响应太长，也打印末尾部分
            if (aiContent.length > 1000) {
                console.log(`[AI分析-讯飞] 响应内容末尾: ...${aiContent.substring(aiContent.length - 500)}`);
            }
            
            // 解析AI响应中的JSON
            let analysisResult;
            try {
                // 尝试直接解析
                analysisResult = JSON.parse(aiContent);
                console.log('[AI分析-讯飞] 直接解析JSON成功');
            } catch (e) {
                console.log('[AI分析-讯飞] 直接解析失败，尝试提取JSON部分');
                console.log('[AI分析-讯飞] 错误信息:', e.message);
                
                // 方法1: 尝试提取markdown代码块中的JSON
                let jsonText = '';
                const codeBlockMatch = aiContent.match(/```(?:json)?\s*(\{[\s\S]*?\})\s*```/);
                if (codeBlockMatch) {
                    jsonText = codeBlockMatch[1];
                    console.log('[AI分析-讯飞] 从markdown代码块中提取JSON');
                } else {
                    // 方法2: 尝试提取第一个完整的JSON对象
                    const jsonMatch = aiContent.match(/\{[\s\S]*\}/);
                    if (jsonMatch) {
                        jsonText = jsonMatch[0];
                        console.log('[AI分析-讯飞] 从响应中提取JSON对象');
                    }
                }
                
                if (jsonText) {
                    try {
                        // 尝试清理JSON文本（移除可能的控制字符）
                        jsonText = jsonText.replace(/[\x00-\x1F\x7F]/g, '');
                        analysisResult = JSON.parse(jsonText);
                        console.log('[AI分析-讯飞] 成功提取并解析JSON');
                    } catch (e2) {
                        console.error('[AI分析-讯飞] 提取的JSON解析失败:', e2.message);
                        console.error('[AI分析-讯飞] 错误位置:', e2.message.match(/position (\d+)/)?.[1] || '未知');
                        
                        // 尝试修复常见的JSON错误
                        try {
                            // 先尝试找到JSON的起始和结束位置
                            let startPos = jsonText.indexOf('{');
                            let endPos = jsonText.lastIndexOf('}');
                            
                            if (startPos >= 0 && endPos > startPos) {
                                jsonText = jsonText.substring(startPos, endPos + 1);
                            }
                            
                            // 尝试修复未转义的引号（在字符串值中）
                            // 使用更智能的方法：识别JSON结构，只修复字符串值中的引号
                            // 策略：找到 "key": "value" 模式，修复value中的引号
                            
                            // 使用状态机方法修复JSON中的未转义引号
                            // 策略：遍历JSON，识别字符串值，转义其中的未转义引号
                            let fixedJson = '';
                            let inString = false;
                            let escapeNext = false;
                            
                            for (let i = 0; i < jsonText.length; i++) {
                                const char = jsonText[i];
                                
                                if (escapeNext) {
                                    // 当前字符是转义序列的一部分
                                    fixedJson += char;
                                    escapeNext = false;
                                    continue;
                                }
                                
                                if (char === '\\') {
                                    // 遇到反斜杠，下一个字符是转义字符
                                    fixedJson += char;
                                    escapeNext = true;
                                    continue;
                                }
                                
                                if (char === '"') {
                                    if (!inString) {
                                        // 字符串开始
                                        inString = true;
                                        fixedJson += char;
                                    } else {
                                        // 在字符串中遇到引号
                                        // 检查后面的字符，判断这是字符串结束还是字符串值中的引号
                                        let j = i + 1;
                                        // 跳过空白字符
                                        while (j < jsonText.length && /\s/.test(jsonText[j])) {
                                            j++;
                                        }
                                        
                                        if (j >= jsonText.length) {
                                            // 到达末尾，这是字符串结束
                                            inString = false;
                                            fixedJson += char;
                                        } else {
                                            const nextNonSpace = jsonText[j];
                                            // 如果下一个非空白字符是:或,或}或]，说明这是字符串结束
                                            if (nextNonSpace === ':' || nextNonSpace === ',' || nextNonSpace === '}' || nextNonSpace === ']') {
                                                inString = false;
                                                fixedJson += char;
                                            } else {
                                                // 这是字符串值中的引号，需要转义
                                                fixedJson += '\\"';
                                            }
                                        }
                                    }
                                } else {
                                    fixedJson += char;
                                }
                            }
                            
                            jsonText = fixedJson;
                            
                            // 尝试解析修复后的JSON
                            analysisResult = JSON.parse(jsonText);
                            console.log('[AI分析-讯飞] 修复后成功解析JSON');
                        } catch (e3) {
                            console.error('[AI分析-讯飞] 修复后仍然失败:', e3.message);
                            
                            // 打印错误位置的上下文
                            const errorPos = parseInt(e3.message.match(/position (\d+)/)?.[1] || '0');
                            if (errorPos > 0) {
                                const start = Math.max(0, errorPos - 100);
                                const end = Math.min(jsonText.length, errorPos + 100);
                                console.error('[AI分析-讯飞] 错误位置上下文:', jsonText.substring(start, end));
                                console.error('[AI分析-讯飞] 错误位置标记:', ' '.repeat(Math.min(100, errorPos - start)) + '^');
                            }
                            
                            console.error('[AI分析-讯飞] 尝试解析的JSON文本（前1000字符）:', jsonText.substring(0, 1000));
                            if (jsonText.length > 1000) {
                                console.error('[AI分析-讯飞] 尝试解析的JSON文本（后1000字符）:', jsonText.substring(Math.max(0, jsonText.length - 1000)));
                            }
                            
                            // 最后尝试：使用eval（不安全，但作为最后的尝试）
                            // 实际上，我们应该避免使用eval，而是抛出错误让用户知道
                            throw new Error(`无法解析AI响应为JSON: ${e2.message}。错误位置: ${errorPos}。请检查AI返回的JSON格式是否正确。`);
                        }
                    }
                } else {
                    console.error('[AI分析-讯飞] 响应中未找到JSON格式');
                    console.error('[AI分析-讯飞] 完整响应内容:', aiContent);
                    throw new Error('AI响应中未找到有效的JSON格式');
                }
            }
            
            // 验证分析结果格式
            if (!analysisResult.issues || !Array.isArray(analysisResult.issues)) {
                console.warn('[AI分析-讯飞] AI返回的格式不正确，使用规则基础分析');
                console.warn('[AI分析-讯飞] 返回的数据结构:', JSON.stringify(analysisResult).substring(0, 500));
                throw new Error('AI返回格式不正确');
            }
            
            console.log(`[AI分析-讯飞] 成功解析，包含 ${analysisResult.issues.length} 个问题的分析结果`);
            console.log(`[AI分析-讯飞] 原始问题数量: ${issues.length}`);
            
            // 检查返回的issues数组长度
            if (analysisResult.issues.length < issues.length) {
                console.warn(`[AI分析-讯飞] AI返回的issues数组长度不足: ${analysisResult.issues.length} < ${issues.length}`);
                console.warn(`[AI分析-讯飞] 将使用规则基础分析补充缺失的问题`);
                
                // 打印AI返回的每个问题的建议长度，用于调试
                analysisResult.issues.forEach((item, idx) => {
                    const suggestion = item.suggestion || '';
                    console.log(`[AI分析-讯飞] 问题 ${idx + 1}: suggestion长度=${suggestion.length}, risk_level=${item.risk_level}, risk_score=${item.risk_score}`);
                });
            }
            
            // 合并分析结果到原始问题
            return issues.map((issue, index) => {
                const analysis = analysisResult.issues && analysisResult.issues[index] ? analysisResult.issues[index] : {};
                const aiSuggestion = analysis.suggestion || '';
                
                // 如果AI返回的数组长度不够，或者建议为空/过短，使用规则基础建议
                if (index >= analysisResult.issues.length) {
                    console.warn(`[AI分析-讯飞] 问题 ${index + 1} 超出AI返回范围，使用规则基础建议`);
                    const risk = this.assessRisk(issue);
                    const suggestion = this.generateSuggestion(issue);
                    return {
                        ...issue,
                        risk_level: risk.level,
                        risk_score: risk.score,
                        suggestion: suggestion,
                        ai_analyzed: false
                    };
                }
                
                // 验证AI返回的建议是否有效
                if (!aiSuggestion || aiSuggestion.trim().length < 20) {
                    console.warn(`[AI分析-讯飞] 问题 ${index + 1} 的AI建议过短或为空，使用规则基础建议`);
                    console.warn(`[AI分析-讯飞] 原始建议: "${aiSuggestion}" (长度: ${aiSuggestion.length})`);
                    const risk = this.assessRisk(issue);
                    const suggestion = this.generateSuggestion(issue);
                    return {
                        ...issue,
                        risk_level: analysis.risk_level || risk.level,
                        risk_score: analysis.risk_score !== undefined ? analysis.risk_score : risk.score,
                        suggestion: suggestion,
                        ai_analyzed: false
                    };
                } else {
                    console.log(`[AI分析-讯飞] 问题 ${index + 1} 获得AI建议，长度: ${aiSuggestion.length} 字符`);
                    return {
                        ...issue,
                        risk_level: analysis.risk_level || this.assessRisk(issue).level,
                        risk_score: analysis.risk_score !== undefined ? analysis.risk_score : this.assessRisk(issue).score,
                        suggestion: aiSuggestion,
                        ai_analyzed: true
                    };
                }
            });
        } catch (error) {
            console.error('[AI分析-讯飞] 批量分析失败:', error);
            // 回退到规则基础分析
            return issues.map(issue => {
                const risk = this.assessRisk(issue);
                const suggestion = this.generateSuggestion(issue);
                return {
                    ...issue,
                    risk_level: risk.level,
                    risk_score: risk.score,
                    suggestion: suggestion,
                    ai_analyzed: false
                };
            });
        }
    }


    /**
     * 构建AI分析提示词
     * 优化：一次性处理所有问题，按文件分组，读取完整文件内容
     */
    async buildAnalysisPrompt(issues, projectPath) {
        // 按文件分组问题
        const issuesByFile = new Map();
        for (const issue of issues) {
            const filePath = issue.relative_path || issue.file;
            if (!issuesByFile.has(filePath)) {
                issuesByFile.set(filePath, []);
            }
            issuesByFile.get(filePath).push(issue);
        }

        console.log(`[AI分析] 问题分布在 ${issuesByFile.size} 个文件中`);

        // 读取每个文件的完整内容
        const filesData = new Map();
        for (const [filePath, fileIssues] of issuesByFile.entries()) {
            try {
                if (filePath && projectPath) {
                    const fullPath = path.join(projectPath, filePath);
                    if (fs.existsSync(fullPath)) {
                        const content = fs.readFileSync(fullPath, 'utf8');
                        filesData.set(filePath, {
                            content: content,
                            issues: fileIssues,
                            lineCount: content.split('\n').length
                        });
                        console.log(`[AI分析] 读取文件: ${filePath} (${content.split('\n').length} 行)`);
                    }
                }
            } catch (error) {
                console.warn(`[AI分析] 无法读取文件 ${filePath}: ${error.message}`);
            }
        }

        // 构建问题列表（包含完整文件内容）
        let issuesText = '';
        let issueIndex = 1;
        
        for (const [filePath, fileData] of filesData.entries()) {
            issuesText += `\n## 文件: ${filePath}\n`;
            issuesText += `完整代码（共 ${fileData.lineCount} 行）：\n\`\`\`python\n${fileData.content}\n\`\`\`\n\n`;
            issuesText += `该文件中的问题：\n`;
            
            for (const issue of fileData.issues) {
                issuesText += `${issueIndex}. 行号: ${issue.line}, 列号: ${issue.column || 0}\n`;
                issuesText += `   规则: ${issue.rule || '未知'}\n`;
                issuesText += `   消息: ${issue.message || '无'}\n`;
                issuesText += `   类型: ${issue.type || 'unknown'}\n`;
                issuesText += `   严重程度: ${issue.severity || 'medium'}\n`;
                issuesText += `   检测工具: ${(issue.detected_by || []).join(', ')}\n\n`;
                issueIndex++;
            }
        }

        // 对于没有文件内容的问题，单独列出
        for (const issue of issues) {
            const filePath = issue.relative_path || issue.file;
            if (!filesData.has(filePath)) {
                issuesText += `${issueIndex}. 文件: ${filePath}\n`;
                issuesText += `   行号: ${issue.line}\n`;
                issuesText += `   规则: ${issue.rule || '未知'}\n`;
                issuesText += `   消息: ${issue.message || '无'}\n\n`;
                issueIndex++;
            }
        }

        return `你是一个专业的Python代码质量分析专家。请分析以下代码检查问题，并提供统一的修复建议。

**重要任务：**
1. **合并重复问题**：首先识别并合并重复或相似的问题（不同工具可能检测到相同的问题）
2. **统一分析**：对所有问题（包括合并后的）进行统一分析
3. **提供详细建议**：为每个问题提供详细的修复建议

**分析要求：**
1. **风险等级**（high/medium/low）：根据问题的严重程度和影响范围评估
2. **风险评分**（0-100）：数值越高表示风险越大，需要优先处理
3. **修改建议**：必须提供详细且具体的修复建议，包括：
   - 问题原因分析
   - 具体的修复步骤
   - 修复前后的代码示例对比
   - 最佳实践建议
   - 避免类似问题的建议

**重要要求：**
- **必须为所有问题提供建议**：返回的issues数组长度必须与原始问题数量完全一致（共 ${issues.length} 个问题）
- **每个问题都必须有suggestion字段**：suggestion字段不能为空，必须包含至少50字的详细建议
- **按顺序对应**：issues数组中的第1个元素对应第1个问题，第2个元素对应第2个问题，以此类推
- **如果问题已合并**：在对应位置返回合并后的分析结果，但必须确保数组长度不变

**注意：**
- 请先合并重复问题，然后对所有问题（包括合并后的）进行分析
- 根据完整代码上下文给出针对性建议
- 建议要具体、可操作，避免空泛的描述
- **绝对不能省略任何问题**：即使问题相似或重复，也必须为每个问题提供独立的分析结果

问题列表（包含完整代码）：
${issuesText}

**请严格按照以下JSON格式返回分析结果，必须确保：**
1. issues数组长度 = ${issues.length}（与原始问题数量完全一致）
2. 每个issue对象都包含完整的suggestion字段（至少50字）
3. 所有字段都必须有值，不能为空
4. **只返回纯JSON，不要包含任何markdown代码块标记（不要使用\`\`\`json\`\`\`包裹）**
5. **JSON中的字符串值必须正确转义**：换行符使用\\n，引号使用\\"，反斜杠使用\\\\

**返回格式（纯JSON，不要任何其他文本）：**
{
  "issues": [
    {
      "risk_level": "high|medium|low",
      "risk_score": 0-100,
      "suggestion": "详细的问题分析、修复步骤、代码示例和最佳实践建议（至少50字，不能为空，字符串中的特殊字符必须正确转义）"
    }
  ]
}

**重要提示：**
- 只返回JSON对象，不要包含任何解释文字
- 不要使用markdown代码块包裹JSON
- JSON字符串中的换行符、引号等特殊字符必须正确转义
- 必须返回 ${issues.length} 个issues，每个都必须有完整的suggestion！**`;
    }

    /**
     * 评估风险（规则基础）
     */
    assessRisk(issue) {
        let score = 0;
        let level = 'low';

        // 基于类型
        if (issue.type === 'error') score += 50;
        else if (issue.type === 'warning') score += 30;
        else score += 10;

        // 基于严重程度
        if (issue.severity === 'high') score += 40;
        else if (issue.severity === 'medium') score += 20;
        else score += 10;

        // 基于规则类型（安全相关规则风险更高）
        const securityKeywords = ['security', 'injection', 'xss', 'csrf', 'sql', 'password', 'secret', 'key', 'token'];
        const ruleLower = (issue.rule || '').toLowerCase();
        const messageLower = (issue.message || '').toLowerCase();
        
        if (securityKeywords.some(keyword => 
            ruleLower.includes(keyword) || messageLower.includes(keyword)
        )) {
            score += 30;
        }

        // 确定风险等级
        if (score >= 70) level = 'high';
        else if (score >= 40) level = 'medium';
        else level = 'low';

        return { level, score };
    }

    /**
     * 生成修改建议（规则基础）
     */
    generateSuggestion(issue) {
        const rule = issue.rule || '';
        const message = issue.message || '';
        const ruleLower = rule.toLowerCase();
        const messageLower = message.toLowerCase();

        // 基于规则类型生成建议
        if (ruleLower.includes('import') || messageLower.includes('import')) {
            return '检查导入语句，确保导入的模块存在且路径正确。考虑使用相对导入或检查PYTHONPATH设置。';
        }
        
        if (ruleLower.includes('unused') || messageLower.includes('unused')) {
            return '删除未使用的变量、函数或导入。如果确实需要保留，可以在变量名前加下划线（如 _unused_var）。';
        }
        
        if (ruleLower.includes('naming') || messageLower.includes('naming')) {
            return '遵循PEP 8命名规范：类名使用驼峰命名（CamelCase），函数和变量使用下划线命名（snake_case）。';
        }
        
        if (ruleLower.includes('security') || messageLower.includes('security') || 
            ruleLower.includes('bandit')) {
            return '这是一个安全问题。请仔细检查代码，确保没有安全漏洞。考虑使用安全的替代方案，如使用参数化查询而不是字符串拼接。';
        }
        
        if (ruleLower.includes('complexity') || messageLower.includes('complexity')) {
            return '代码复杂度过高。考虑将函数拆分为更小的函数，提高代码可读性和可维护性。';
        }
        
        if (messageLower.includes('line too long')) {
            return '行长度超过限制。将长行拆分为多行，或使用括号、反斜杠进行换行。';
        }
        
        if (messageLower.includes('missing docstring')) {
            return '添加函数或类的文档字符串（docstring），说明其功能、参数和返回值。';
        }

        // 默认建议
        return `根据规则"${rule}"的建议：${message}。请参考相关代码规范文档进行修改。`;
    }
}

module.exports = new AIAnalyzer();