import ast
import javalang
import esprima
from typing import Dict, Any, List
from abc import ABC, abstractmethod
class BaseASTParser(ABC):
    """抽象语法树解析器基类"""
    
    @abstractmethod
    def parse(self, source_code: str) -> Dict[str, Any]:
        """解析源代码生成AST"""
        pass
    
    @abstractmethod
    def extract_structure(self, ast_node) -> Dict[str, Any]:
        """提取代码结构信息"""
        pass
class PythonASTParser(BaseASTParser):
    """Python代码AST解析器"""
    
    def parse(self, source_code: str) -> Dict[str, Any]:
        try:
            tree = ast.parse(source_code)
            return {
                'ast': tree,
                'structure': self.extract_structure(tree),
                'language': 'python'
            }
        except SyntaxError as e:
            return {'error': f'Python语法错误: {e}'}
    
    def extract_structure(self, ast_node) -> Dict[str, Any]:
        """提取Python代码结构"""
        structure = {
            'classes': [],
            'functions': [],
            'imports': [],
            'variables': []
        }
        
        for node in ast.walk(ast_node):
            if isinstance(node, ast.ClassDef):
                structure['classes'].append({
                    'name': node.name,
                    'methods': [n.name for n in node.body if isinstance(n, ast.FunctionDef)],
                    'decorators': [ast.unparse(d) for d in node.decorator_list]
                })
            elif isinstance(node, ast.FunctionDef):
                structure['functions'].append({
                    'name': node.name,
                    'args': [arg.arg for arg in node.args.args],
                    'returns': ast.unparse(node.returns) if node.returns else None
                })
            elif isinstance(node, ast.Import):
                structure['imports'].extend([alias.name for alias in node.names])
                
        return structure
class JavaASTParser(BaseASTParser):
    """Java代码AST解析器"""
    
    def parse(self, source_code: str) -> Dict[str, Any]:
        try:
            tree = javalang.parse.parse(source_code)
            return {
                'ast': tree,
                'structure': self.extract_structure(tree),
                'language': 'java'
            }
        except Exception as e:
            return {'error': f'Java解析错误: {e}'}
    
    def extract_structure(self, ast_node) -> Dict[str, Any]:
        """提取Java代码结构"""
        structure = {
            'package': ast_node.package.name if ast_node.package else None,
            'imports': [imp.path for imp in ast_node.imports],
            'classes': [],
            'interfaces': []
        }
        
        for _, node in ast_node.filter(javalang.tree.ClassDeclaration):
            methods = []
            for method in node.methods:
                methods.append({
                    'name': method.name,
                    'modifiers': method.modifiers,
                    'return_type': method.return_type.name if method.return_type else 'void'
                })
            
            structure['classes'].append({
                'name': node.name,
                'modifiers': node.modifiers,
                'methods': methods
            })
        
        return structure
class MultiLanguageParser:
    """多语言统一解析器"""
    
    def __init__(self):
        self.parsers = {
            'python': PythonASTParser(),
            'java': JavaASTParser(),
            'javascript': JavaScriptASTParser()
        }
    
    def parse_code(self, source_code: str, language: str) -> Dict[str, Any]:
        """统一解析接口"""
        if language not in self.parsers:
            return {'error': f'不支持的语言: {language}'}
        
        parser = self.parsers[language]
        return parser.parse(source_code)
    
    def get_code_context(self, source_code: str, language: str) -> Dict[str, Any]:
        """获取代码上下文信息"""
        parse_result = self.parse_code(source_code, language)
        
        if 'error' in parse_result:
            return parse_result
        
        # 提取语义信息
        semantic_info = self._extract_semantic_info(parse_result['structure'])
        
        return {
            'structure': parse_result['structure'],
            'semantic': semantic_info,
            'complexity': self._calculate_complexity(parse_result['structure']),
            'language': language
        }
    
    def _extract_semantic_info(self, structure: Dict[str, Any]) -> Dict[str, Any]:
        """提取语义信息"""
        return {
            'design_patterns': self._detect_patterns(structure),
            'code_smells': self._detect_code_smells(structure),
            'dependencies': self._analyze_dependencies(structure)
        }
    
    def _calculate_complexity(self, structure: Dict[str, Any]) -> int:
        """计算代码复杂度"""
        complexity = 0
        if 'functions' in structure:
            complexity += len(structure['functions']) * 2
        if 'classes' in structure:
            complexity += len(structure['classes']) * 3
        return complexity

from typing import Dict, Any, List
import openai
from jinja2 import Template
class CodeGenerationEngine:
    """智能代码生成引擎"""
    
    def __init__(self, api_key: str):
        self.openai_client = openai.OpenAI(api_key=api_key)
        self.template_loader = CodeTemplateLoader()
        self.context_analyzer = CodeContextAnalyzer()
    
    def generate_code(self, 
                     prompt: str, 
                     language: str, 
                     context: Dict[str, Any] = None) -> Dict[str, Any]:
        """核心代码生成方法"""
        
        # 1. 分析生成意图
        intent = self._analyze_intent(prompt)
        
        # 2. 准备生成上下文
        generation_context = self._prepare_context(context, language, intent)
        
        # 3. 选择生成策略
        if intent['type'] == 'template_based':
            return self._generate_from_template(intent, generation_context)
        else:
            return self._generate_with_llm(prompt, generation_context)
    
    def _analyze_intent(self, prompt: str) -> Dict[str, Any]:
        """分析用户意图"""
        intent_patterns = {
            'class_creation': ['创建类', 'class', '定义类'],
            'function_creation': ['函数', 'function', '方法', 'method'],
            'api_endpoint': ['API', 'endpoint', '接口'],
            'data_processing': ['处理数据', 'process', '转换'],
            'test_generation': ['测试', 'test', 'unit test']
        }
        
        for intent_type, keywords in intent_patterns.items():
            if any(keyword in prompt.lower() for keyword in keywords):
                return {
                    'type': intent_type,
                    'confidence': 0.8,
                    'keywords': [kw for kw in keywords if kw in prompt.lower()]
                }
        
        return {'type': 'general', 'confidence': 0.5}
    
    def _prepare_context(self, 
                        context: Dict[str, Any], 
                        language: str, 
                        intent: Dict[str, Any]) -> Dict[str, Any]:
        """准备生成上下文"""
        generation_context = {
            'language': language,
            'intent': intent,
            'existing_code': context.get('structure', {}) if context else {},
            'project_style': self._infer_coding_style(context),
            'dependencies': context.get('semantic', {}).get('dependencies', []) if context else []
        }
        
        # 添加语言特定的上下文
        if language == 'python':
            generation_context.update({
                'style_guide': 'PEP8',
                'common_imports': ['typing', 'dataclasses', 'abc'],
                'naming_convention': 'snake_case'
            })
        elif language == 'java':
            generation_context.update({
                'style_guide': 'Google Java Style',
                'common_annotations': ['@Override', '@Deprecated', '@SuppressWarnings'],
                'naming_convention': 'camelCase'
            })
        
        return generation_context
    
    def _generate_with_llm(self, prompt: str, context: Dict[str, Any]) -> Dict[str, Any]:
        """使用LLM生成代码"""
        system_prompt = self._build_system_prompt(context)
        
        try:
            response = self.openai_client.chat.completions.create(
                model="gpt-4",
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": prompt}
                ],
                temperature=0.2,
                max_tokens=2000
            )
            
            generated_code = response.choices[0].message.content
            
            return {
                'code': generated_code,
                'language': context['language'],
                'confidence': 0.9,
                'suggestions': self._generate_suggestions(generated_code, context)
            }
            
        except Exception as e:
            return {'error': f'代码生成失败: {e}'}
    
    def _build_system_prompt(self, context: Dict[str, Any]) -> str:
        """构建系统提示词"""
        language = context['language']
        style_guide = context.get('style_guide', '')
        
        return f"""你是一个专业的{language}代码生成助手。
        
请根据以下要求生成代码：
1. 遵循{style_guide}编码规范
2. 使用{context.get('naming_convention', '')}命名约定
3. 生成的代码应该包含适当的注释
4. 考虑现有代码结构：{context.get('existing_code', {})}
5. 确保代码的可读性和可维护性
生成的代码应该：
- 语法正确且可执行
- 遵循最佳实践
- 包含错误处理
- 提供清晰的文档字符串或注释
"""
class CodeTemplateLoader:
    """代码模板加载器"""
    
    def __init__(self):
        self.templates = self._load_templates()
    
    def _load_templates(self) -> Dict[str, Template]:
        """加载代码模板"""
        templates = {}
        
        # Python类模板
        python_class_template = Template("""
class {{ class_name }}:
    \"\"\"{{ class_description }}\"\"\"
    
    def __init__(self{% for param in init_params %}, {{ param.name }}: {{ param.type }}{% endfor %}):
        {% for param in init_params %}
        self.{{ param.name }} = {{ param.name }}
        {% endfor %}
    
    {% for method in methods %}
    def {{ method.name }}(self{% for param in method.params %}, {{ param.name }}: {{ param.type }}{% endfor %}){% if method.return_type %} -> {{ method.return_type }}{% endif %}:
        \"\"\"{{ method.description }}\"\"\"
        # TODO: 实现{{ method.name }}方法
        pass
    {% endfor %}
""")
        
        templates['python_class'] = python_class_template
        return templates
    
    def get_template(self, template_name: str) -> Template:
        """获取指定模板"""
        return self.templates.get(template_name)

interface FrameworkAdapter {
    name: string;
    language: string;
    patterns: CodePattern[];
    generateBoilerplate(config: ProjectConfig): string;
    adaptCode(code: string, context: FrameworkContext): string;
}
class SpringBootAdapter implements FrameworkAdapter {
    name = 'Spring Boot';
    language = 'java';
    patterns: CodePattern[] = [
        {
            name: 'RestController',
            template: `
@RestController
@RequestMapping("/api/{{ endpoint }}")
public class {{ className }}Controller {
    
    @Autowired
    private {{ serviceName }} {{ serviceInstance }};
    
    @GetMapping
    public ResponseEntity<List<{{ entityName }}>> getAll() {
        List<{{ entityName }}> result = {{ serviceInstance }}.findAll();
        return ResponseEntity.ok(result);
    }
    
    @PostMapping
    public ResponseEntity<{{ entityName }}> create(@RequestBody {{ entityName }} entity) {
        {{ entityName }} saved = {{ serviceInstance }}.save(entity);
        return ResponseEntity.status(HttpStatus.CREATED).body(saved);
    }
}`,
            variables: ['endpoint', 'className', 'serviceName', 'serviceInstance', 'entityName']
        }
    ];
    
    generateBoilerplate(config: ProjectConfig): string {
        return `
// Spring Boot主应用类
@SpringBootApplication
public class ${config.projectName}Application {
    public static void main(String[] args) {
        SpringApplication.run(${config.projectName}Application.class, args);
    }
}
// 应用配置
@Configuration
@EnableJpaRepositories
public class DatabaseConfig {
    // 数据库配置
}
`;
    }
    
    adaptCode(code: string, context: FrameworkContext): string {
        // Spring Boot特定的代码适配逻辑
        let adaptedCode = code;
        
        // 添加必要的注解
        if (context.isService) {
            adaptedCode = `@Service\n${adaptedCode}`;
        }
        
        // 添加依赖注入
        adaptedCode = this.addDependencyInjection(adaptedCode, context);
        
        return adaptedCode;
    }
    
    private addDependencyInjection(code: string, context: FrameworkContext): string {
        // 实现依赖注入逻辑
        return code;
    }
}
class ReactAdapter implements FrameworkAdapter {
    name = 'React';
    language = 'typescript';
    patterns: CodePattern[] = [
        {
            name: 'FunctionalComponent',
            template: `
import React, { useState, useEffect } from 'react';
interface {{ componentName }}Props {
    {{ propsDefinition }}
}
const {{ componentName }}: React.FC<{{ componentName }}Props> = ({{ props }}) => {
    {{ stateDefinitions }}
    
    useEffect(() => {
        // 副作用逻辑
    }, []);
    
    return (
        <div className="{{ componentName }}">
            {{ componentContent }}
        </div>
    );
};
export default {{ componentName }};`,
            variables: ['componentName', 'propsDefinition', 'props', 'stateDefinitions', 'componentContent']
        }
    ];
    
    generateBoilerplate(config: ProjectConfig): string {
        return `
// React应用入口
import React from 'react';
import ReactDOM from 'react-dom/client';
import App from './App';
const root = ReactDOM.createRoot(document.getElementById('root')!);
root.render(<App />);
`;
    }
    
    adaptCode(code: string, context: FrameworkContext): string {
        // React特定的代码适配
        return this.addReactImports(code);
    }
    
    private addReactImports(code: string): string {
        if (!code.includes('import React')) {
            return `import React from 'react';\n${code}`;
        }
        return code;
    }
}
class FrameworkManager {
    private adapters: Map<string, FrameworkAdapter> = new Map();
    
    constructor() {
        this.registerAdapter(new SpringBootAdapter());
        this.registerAdapter(new ReactAdapter());
        // 注册更多框架适配器...
    }
    
    registerAdapter(adapter: FrameworkAdapter): void {
        this.adapters.set(adapter.name, adapter);
    }
    
    generateCode(framework: string, pattern: string, variables: Record<string, string>): string {
        const adapter = this.adapters.get(framework);
        if (!adapter) {
            throw new Error(`不支持的框架: ${framework}`);
        }
        
        const codePattern = adapter.patterns.find(p => p.name === pattern);
        if (!codePattern) {
            throw new Error(`找不到模式: ${pattern}`);
        }
        
        return this.renderTemplate(codePattern.template, variables);
    }
    
    private renderTemplate(template: string, variables: Record<string, string>): string {
        let result = template;
        for (const [key, value] of Object.entries(variables)) {
            result = result.replace(new RegExp(`{{ ${key} }}`, 'g'), value);
        }
        return result;
    }
}

from typing import Dict, List, Any
import ast
import re
from dataclasses import dataclass
from enum import Enum
class QualityLevel(Enum):
    EXCELLENT = "优秀"
    GOOD = "良好"
    AVERAGE = "一般"
    POOR = "较差"
@dataclass
class QualityMetric:
    name: str
    score: float
    weight: float
    suggestions: List[str]
    
class CodeQualityAssessor:
    """代码质量评估器"""
    
    def __init__(self):
        self.checkers = {
            'syntax': SyntaxChecker(),
            'style': StyleChecker(),
            'complexity': ComplexityChecker(),
            'security': SecurityChecker(),
            'performance': PerformanceChecker()
        }
        
        # 权重配置
        self.weights = {
            'syntax': 0.4,
            'style': 0.25,
            'complexity': 0.2,
            'security': 0.1,
            'performance': 0.05
        }
    
    def assess_code(self, code: str, language: str) -> Dict[str, Any]:
        """全面评估代码质量"""
        metrics = {}
        total_score = 0
        all_suggestions = []
        
        for checker_name, checker in self.checkers.items():
            try:
                metric = checker.check(code, language)
                metrics[checker_name] = metric
                
                # 计算加权分数
                weighted_score = metric.score * self.weights[checker_name]
                total_score += weighted_score
                
                # 收集建议
                all_suggestions.extend(metric.suggestions)
                
            except Exception as e:
                metrics[checker_name] = QualityMetric(
                    name=checker_name,
                    score=0,
                    weight=self.weights[checker_name],
                    suggestions=[f"{checker_name}检查失败: {e}"]
                )
        
        quality_level = self._determine_quality_level(total_score)
        
        return {
            'overall_score': round(total_score, 2),
            'quality_level': quality_level,
            'metrics': metrics,
            'suggestions': all_suggestions,
            'detailed_report': self._generate_detailed_report(metrics, total_score)
        }
    
    def _determine_quality_level(self, score: float) -> QualityLevel:
        """确定质量等级"""
        if score >= 0.9:
            return QualityLevel.EXCELLENT
        elif score >= 0.7:
            return QualityLevel.GOOD
        elif score >= 0.5:
            return QualityLevel.AVERAGE
        else:
            return QualityLevel.POOR
    
    def _generate_detailed_report(self, metrics: Dict[str, QualityMetric], total_score: float) -> str:
        """生成详细报告"""
        report = f"=== 代码质量评估报告 ===\n"
        report += f"总体评分: {total_score:.2f}/1.0\n\n"
        
        for name, metric in metrics.items():
            report += f"{metric.name}评估:\n"
            report += f"  分数: {metric.score:.2f} (权重: {metric.weight:.2f})\n"
            if metric.suggestions:
                report += f"  建议:\n"
                for suggestion in metric.suggestions:
                    report += f"    - {suggestion}\n"
            report += "\n"
        
        return report
class SyntaxChecker:
    """语法检查器"""
    
    def check(self, code: str, language: str) -> QualityMetric:
        suggestions = []
        
        if language == 'python':
            score = self._check_python_syntax(code, suggestions)
        elif language == 'java':
            score = self._check_java_syntax(code, suggestions)
        else:
            score = 0.5  # 不支持的语言给默认分数
            suggestions.append(f"暂不支持{language}语法检查")
        
        return QualityMetric(
            name="语法正确性",
            score=score,
            weight=0.4,
            suggestions=suggestions
        )
    
    def _check_python_syntax(self, code: str, suggestions: List[str]) -> float:
        """检查Python语法"""
        try:
            ast.parse(code)
            return 1.0
        except SyntaxError as e:
            suggestions.append(f"语法错误: {e.msg} (行 {e.lineno})")
            return 0.0
        except Exception as e:
            suggestions.append(f"解析错误: {e}")
            return 0.2
class StyleChecker:
    """代码风格检查器"""
    
    def check(self, code: str, language: str) -> QualityMetric:
        suggestions = []
        issues = 0
        total_checks = 0
        
        if language == 'python':
            issues, total_checks = self._check_python_style(code, suggestions)
        elif language == 'java':
            issues, total_checks = self._check_java_style(code, suggestions)
        
        score = max(0, (total_checks - issues) / total_checks) if total_checks > 0 else 0.5
        
        return QualityMetric(
            name="代码规范",
            score=score,
            weight=0.25,
            suggestions=suggestions
        )
    
    def _check_python_style(self, code: str, suggestions: List[str]) -> tuple:
        """检查Python代码风格"""
        issues = 0
        total_checks = 5
        
        # 检查缩进
        if '    ' not in code and '\t' in code:
            suggestions.append("建议使用4个空格而不是制表符进行缩进")
            issues += 1
        
        # 检查行长度
        lines = code.split('\n')
        long_lines = [i+1 for i, line in enumerate(lines) if len(line) > 79]
        if long_lines:
            suggestions.append(f"以下行超过79字符限制: {long_lines}")
            issues += 1
        
        # 检查函数命名
        function_pattern = r'def\s+([A-Z]\w*)\s*\('
        if re.search(function_pattern, code):
            suggestions.append("函数名应使用snake_case命名规范")
            issues += 1
        
        # 检查导入规范
        import_lines = [line for line in lines if line.strip().startswith('import') or line.strip().startswith('from')]
        if len(import_lines) > 0:
            # 检查是否有星号导入
            star_imports = [line for line in import_lines if ' * ' in line]
            if star_imports:
                suggestions.append("避免使用星号导入 (from module import *)")
                issues += 1
        
        # 检查文档字符串
        if 'def ' in code and '"""' not in code and "'''" not in code:
            suggestions.append("建议为函数添加文档字符串")
            issues += 1
        
        return issues, total_checks
class ComplexityChecker:
    """复杂度检查器"""
    
    def check(self, code: str, language: str) -> QualityMetric:
        suggestions = []
        
        if language == 'python':
            complexity_score = self._calculate_python_complexity(code, suggestions)
        else:
            complexity_score = 0.7  # 默认分数
        
        return QualityMetric(
            name="代码复杂度",
            score=complexity_score,
            weight=0.2,
            suggestions=suggestions
        )
    
    def _calculate_python_complexity(self, code: str, suggestions: List[str]) -> float:
        """计算Python代码复杂度"""
        try:
            tree = ast.parse(code)
            total_complexity = 0
            function_count = 0
            
            for node in ast.walk(tree):
                if isinstance(node, ast.FunctionDef):
                    function_count += 1
                    func_complexity = self._calculate_cyclomatic_complexity(node)
                    total_complexity += func_complexity
                    
                    if func_complexity > 10:
                        suggestions.append(f"函数 '{node.name}' 复杂度过高 ({func_complexity}), 建议重构")
            
            if function_count == 0:
                return 0.8
            
            avg_complexity = total_complexity / function_count
            
            # 复杂度评分：越低越好
            if avg_complexity <= 5:
                return 1.0
            elif avg_complexity <= 10:
                return 0.8
            elif avg_complexity <= 15:
                return 0.6
            else:
                return 0.3
                
        except Exception:
            return 0.5
    
    def _calculate_cyclomatic_complexity(self, func_node) -> int:
        """计算圈复杂度"""
        complexity = 1  # 基础复杂度
        
        for node in ast.walk(func_node):
            if isinstance(node, (ast.If, ast.While, ast.For, ast.Try)):
                complexity += 1
            elif isinstance(node, ast.BoolOp):
                complexity += len(node.values) - 1
        
        return complexity
class SecurityChecker:
    """安全性检查器"""
    
    def check(self, code: str, language: str) -> QualityMetric:
        suggestions = []
        security_issues = 0
        
        # 通用安全检查
        security_patterns = {
            r'eval\s*\(': "避免使用eval()函数，存在代码注入风险",
            r'exec\s*\(': "避免使用exec()函数，存在代码注入风险",
            r'password\s*=\s*["\'][^"\']*["\']': "避免在代码中硬编码密码",
            r'api_key\s*=\s*["\'][^"\']*["\']': "避免在代码中硬编码API密钥",
            r'subprocess\.call\(["\'][^"\']*["\']': "使用subprocess时注意命令注入风险"
        }
        
        for pattern, message in security_patterns.items():
            if re.search(pattern, code, re.IGNORECASE):
                suggestions.append(message)
                security_issues += 1
        
        # 计算安全分数
        if security_issues == 0:
            score = 1.0
        elif security_issues <= 2:
            score = 0.7
        elif security_issues <= 5:
            score = 0.4
        else:
            score = 0.1
        
        return QualityMetric(
            name="安全性",
            score=score,
            weight=0.1,
            suggestions=suggestions
        )
class PerformanceChecker:
    """性能检查器"""
    
    def check(self, code: str, language: str) -> QualityMetric:
        suggestions = []
        
        if language == 'python':
            score = self._check_python_performance(code, suggestions)
        else:
            score = 0.8  # 默认分数
        
        return QualityMetric(
            name="性能优化",
            score=score,
            weight=0.05,
            suggestions=suggestions
        )
    
    def _check_python_performance(self, code: str, suggestions: List[str]) -> float:
        """检查Python性能问题"""
        performance_score = 1.0
        
        # 检查低效的字符串拼接
        if re.search(r'\+\s*=.*str', code):
            suggestions.append("避免在循环中使用+=进行字符串拼接，使用join()方法")
            performance_score -= 0.2
        
        # 检查列表推导式机会
        if 'for ' in code and 'append(' in code:
            suggestions.append("考虑使用列表推导式替代for循环和append")
            performance_score -= 0.1
        
        # 检查不必要的函数调用
        if re.search(r'len\([^)]+\)\s*==\s*0', code):
            suggestions.append("使用 'not sequence' 而不是 'len(sequence) == 0'")
            performance_score -= 0.1
        
        return max(0, performance_score)

import * as vscode from 'vscode';
import { CodeGenerationProvider } from './providers/codeGenerationProvider';
import { QualityAssessmentProvider } from './providers/qualityAssessmentProvider';
import { LanguageClient, LanguageClientOptions, ServerOptions, TransportKind } from 'vscode-languageclient/node';
export function activate(context: vscode.ExtensionContext) {
    console.log('AI编程助手扩展已激活');
    
    // 初始化语言客户端
    const languageClient = createLanguageClient(context);
    
    // 注册代码生成提供者
    const codeGenProvider = new CodeGenerationProvider(languageClient);
    
    // 注册质量评估提供者
    const qualityProvider = new QualityAssessmentProvider();
    
    // 注册命令
    registerCommands(context, codeGenProvider, qualityProvider);
    
    // 注册代码补全提供者
    registerCompletionProviders(context, codeGenProvider);
    
    // 启动语言客户端
    languageClient.start();
    
    context.subscriptions.push(languageClient);
}
function createLanguageClient(context: vscode.ExtensionContext): LanguageClient {
    const serverModule = context.asAbsolutePath('out/server/server.js');
    
    const serverOptions: ServerOptions = {
        run: { module: serverModule, transport: TransportKind.ipc },
        debug: { module: serverModule, transport: TransportKind.ipc }
    };
    
    const clientOptions: LanguageClientOptions = {
        documentSelector: [
            { scheme: 'file', language: 'python' },
            { scheme: 'file', language: 'java' },
            { scheme: 'file', language: 'typescript' },
            { scheme: 'file', language: 'javascript' }
        ],
        synchronize: {
            fileEvents: vscode.workspace.createFileSystemWatcher('**/.{py,java,ts,js}')
        }
    };
    
    return new LanguageClient(
        'aiCodingAssistant',
        'AI编程助手',
        serverOptions,
        clientOptions
    );
}
function registerCommands(
    context: vscode.ExtensionContext,
    codeGenProvider: CodeGenerationProvider,
    qualityProvider: QualityAssessmentProvider
) {
    
    // 生成代码命令
    const generateCodeCommand = vscode.commands.registerCommand(
        'aiCodingAssistant.generateCode',
        async () => {
            const editor = vscode.window.activeTextEditor;
            if (!editor) {
                vscode.window.showErrorMessage('请先打开一个文件');
                return;
            }
            
            const prompt = await vscode.window.showInputBox({
                prompt: '请描述你想要生成的代码',
                placeHolder: '例如：创建一个用户管理的REST API'
            });
            
            if (prompt) {
                await codeGenProvider.generateCode(editor, prompt);
            }
        }
    );
    
    // 质量评估命令
    const assessQualityCommand = vscode.commands.registerCommand(
        'aiCodingAssistant.assessQuality',
        async () => {
            const editor = vscode.window.activeTextEditor;
            if (!editor) {
                vscode.window.showErrorMessage('请先打开一个文件');
                return;
            }
            
            const document = editor.document;
            const code = document.getText();
            const language = document.languageId;
            
            await qualityProvider.assessCode(code, language);
        }
    );
    
    // 优化代码建议命令
    const optimizeCodeCommand = vscode.commands.registerCommand(
        'aiCodingAssistant.optimizeCode',
        async () => {
            const editor = vscode.window.activeTextEditor;
            if (!editor) return;
            
            const selection = editor.selection;
            const selectedText = editor.document.getText(selection);
            
            if (selectedText) {
                await codeGenProvider.optimizeCode(editor, selectedText);
            }
        }
    );
    
    context.subscriptions.push(generateCodeCommand, assessQualityCommand, optimizeCodeCommand);
}
function registerCompletionProviders(
    context: vscode.ExtensionContext,
    codeGenProvider: CodeGenerationProvider
) {
    
    // Python代码补全
    const pythonCompletionProvider = vscode.languages.registerCompletionItemProvider(
        'python',
        {
            provideCompletionItems(document, position, token, context) {
                return codeGenProvider.provideCompletionItems(document, position, 'python');
            }
        },
        '.'  // 触发字符
    );
    
    // Java代码补全
    const javaCompletionProvider = vscode.languages.registerCompletionItemProvider(
        'java',
        {
            provideCompletionItems(document, position, token, context) {
                return codeGenProvider.provideCompletionItems(document, position, 'java');
            }
        },
        '.'
    );
    
    context.subscriptions.push(pythonCompletionProvider, javaCompletionProvider);
}
// 代码生成提供者实现
class CodeGenerationProvider {
    private languageClient: LanguageClient;
    private apiEndpoint = 'http://localhost:8080/api';
    
    constructor(languageClient: LanguageClient) {
        this.languageClient = languageClient;
    }
    
    async generateCode(editor: vscode.TextEditor, prompt: string): Promise<void> {
        const document = editor.document;
        const language = document.languageId;
        const currentCode = document.getText();
        
        // 显示进度
        vscode.window.withProgress({
            location: vscode.ProgressLocation.Notification,
            title: "正在生成代码...",
            cancellable: true
        }, async (progress, token) => {
            try {
                const response = await this.callGenerationAPI({
                    prompt,
                    language,
                    context: currentCode,
                    cursor_position: document.offsetAt(editor.selection.active)
                });
                
                if (response.success) {
                    await this.insertGeneratedCode(editor, response.code);
                    
                    // 显示质量评估
                    if (response.quality_assessment) {
                        this.showQualityAssessment(response.quality_assessment);
                    }
                } else {
                    vscode.window.showErrorMessage(`代码生成失败: ${response.error}`);
                }
                
            } catch (error) {
                vscode.window.showErrorMessage(`请求失败: ${error}`);
            }
        });
    }
    
    async optimizeCode(editor: vscode.TextEditor, selectedCode: string): Promise<void> {
        const language = editor.document.languageId;
        
        try {
            const response = await this.callOptimizationAPI({
                code: selectedCode,
                language: language
            });
            
            if (response.success) {
                // 显示优化建议
                const action = await vscode.window.showInformationMessage(
                    `发现 ${response.suggestions.length} 个优化建议`,
                    '查看详情',
                    '应用优化'
                );
                
                if (action === '查看详情') {
                    this.showOptimizationPanel(response.suggestions);
                } else if (action === '应用优化') {
                    await this.applyOptimizations(editor, response.optimized_code);
                }
            }
            
        } catch (error) {
            vscode.window.showErrorMessage(`优化失败: ${error}`);
        }
    }
    
    async provideCompletionItems(
        document: vscode.TextDocument,
        position: vscode.Position,
        language: string
    ): Promise<vscode.CompletionItem[]> {
        
        const linePrefix = document.lineAt(position).text.substr(0, position.character);
        const context = document.getText(new vscode.Range(
            new vscode.Position(Math.max(0, position.line - 10), 0),
            position
        ));
        
        try {
            const response = await this.callCompletionAPI({
                context,
                language,
                prefix: linePrefix
            });
            
            return response.completions.map((completion: any) => {
                const item = new vscode.CompletionItem(completion.text, vscode.CompletionItemKind.Snippet);
                item.detail = completion.description;
                item.documentation = new vscode.MarkdownString(completion.documentation);
                item.insertText = new vscode.SnippetString(completion.text);
                return item;
            });
            
        } catch (error) {
            console.error('补全请求失败:', error);
            return [];
        }
    }
    
    private async insertGeneratedCode(editor: vscode.TextEditor, code: string): Promise<void> {
        const position = editor.selection.active;
        await editor.edit(editBuilder => {
            editBuilder.insert(position, code);
        });
        
        // 格式化代码
        await vscode.commands.executeCommand('editor.action.formatDocument');
    }
    
    private async callGenerationAPI(request: any): Promise<any> {
        const response = await fetch(`${this.apiEndpoint}/generate`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(request)
        });
        
        return await response.json();
    }
    
    private async callOptimizationAPI(request: any): Promise<any> {
        const response = await fetch(`${this.apiEndpoint}/optimize`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(request)
        });
        
        return await response.json();
    }
    
    private async callCompletionAPI(request: any): Promise<any> {
        const response = await fetch(`${this.apiEndpoint}/complete`, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(request)
        });
        
        return await response.json();
    }
    
    private showQualityAssessment(assessment: any): void {
        // 创建WebView显示质量评估结果
        const panel = vscode.window.createWebviewPanel(
            'qualityAssessment',
            '代码质量评估',
            vscode.ViewColumn.Beside,
            { enableScripts: true }
        );
        
        panel.webview.html = this.generateQualityHTML(assessment);
    }
    
    private generateQualityHTML(assessment: any): string {
        return `
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body { font-family: Arial, sans-serif; padding: 20px; }
                .score { font-size: 24px; font-weight: bold; color: #4CAF50; }
                .metric { margin: 10px 0; padding: 10px; border-left: 4px solid #2196F3; }
                .suggestion { margin: 5px 0; padding: 5px; background: #f5f5f5; }
            </style>
        </head>
        <body>
            <h2>代码质量评估报告</h2>
            <div class="score">总体评分: ${assessment.overall_score}/1.0</div>
            <div class="quality-level">质量等级: ${assessment.quality_level}</div>
            
            <h3>详细指标</h3>
            ${Object.entries(assessment.metrics).map(([key, metric]: [string, any]) => `
                <div class="metric">
                    <strong>${metric.name}</strong>: ${metric.score.toFixed(2)}
                    ${metric.suggestions.map((s: string) => `<div class="suggestion">💡 ${s}</div>`).join('')}
                </div>
            `).join('')}
        </body>
        </html>
        `;
    }
}