"""
Agent自主迭代框架 - Python实现
实现基于测试用例的自动化代码迭代优化
"""

import asyncio
import hashlib
import time
from dataclasses import dataclass, field
from enum import Enum
from typing import Any, Callable, Optional
from datetime import datetime
import json


class IterationStatus(Enum):
    """迭代状态枚举"""
    PENDING = "pending"
    RUNNING = "running"
    SUCCESS = "success"
    FAILED = "failed"
    TIMEOUT = "timeout"
    HUMAN_REVIEW = "human_review"


@dataclass
class TestCase:
    """测试用例"""
    name: str
    description: str
    test_func: Callable[[], bool]
    timeout_seconds: int = 60
    priority: int = 1


@dataclass
class IterationResult:
    """迭代结果"""
    iteration_id: str
    status: IterationStatus
    code_changes: str
    test_results: dict[str, bool]
    performance_metrics: dict[str, float]
    duration_seconds: float
    ai_explanation: str = ""
    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())


class TestDrivenIterationFramework:
    """
    测试驱动迭代框架
    
    核心思想：
    1. 以测试用例的通过率和性能指标为驱动信号
    2. Agent自主完成多轮迭代，人类只在关键节点干预
    3. 每次迭代都生成可解释的代码差异报告
    """
    
    def __init__(
        self,
        model_name: str = "claude-sonnet-4-20250514",
        max_iterations: int = 100,
        improvement_threshold: float = 0.01,
        human_review_interval: int = 10
    ):
        self.model_name = model_name
        self.max_iterations = max_iterations
        self.improvement_threshold = improvement_threshold
        self.human_review_interval = human_review_interval
        
        self.test_suite: list[TestCase] = []
        self.iteration_history: list[IterationResult] = []
        self.current_code: str = ""
        self.performance_baseline: dict[str, float] = {}
        
    def register_test(self, test: TestCase) -> None:
        """注册测试用例"""
        self.test_suite.append(test)
        # 按优先级排序
        self.test_suite.sort(key=lambda t: t.priority, reverse=True)
        
    async def run_tests(self, code: str) -> tuple[dict[str, bool], dict[str, float]]:
        """运行测试套件并收集性能指标"""
        test_results = {}
        performance_metrics = {}
        
        for test in self.test_suite:
            try:
                start_time = time.time()
                result = await asyncio.wait_for(
                    asyncio.to_thread(test.test_func),
                    timeout=test.timeout_seconds
                )
                duration = time.time() - start_time
                
                test_results[test.name] = result
                performance_metrics[f"{test.name}_duration"] = duration
                
            except asyncio.TimeoutError:
                test_results[test.name] = False
                performance_metrics[f"{test.name}_duration"] = test.timeout_seconds
            except Exception as e:
                test_results[test.name] = False
                performance_metrics[f"{test.name}_error"] = 1.0
                
        return test_results, performance_metrics
    
    async def generate_code_improvement(
        self,
        current_code: str,
        test_results: dict[str, bool],
        performance_metrics: dict[str, float]
    ) -> tuple[str, str]:
        """
        生成代码改进
        
        返回: (改进后的代码, 自然语言解释)
        """
        # 构建上下文
        context = self._build_context(current_code, test_results, performance_metrics)
        
        # 模拟Claude API调用
        improved_code = await self._call_claude_api(context)
        explanation = self._generate_explanation(test_results, performance_metrics)
        
        return improved_code, explanation
    
    def _build_context(
        self,
        current_code: str,
        test_results: dict[str, bool],
        performance_metrics: dict[str, float]
    ) -> str:
        """构建Claude API上下文"""
        failed_tests = [name for name, result in test_results.items() if not result]
        
        context = f"""
Current Code:
```{current_code}```

Test Results:
{json.dumps(test_results, indent=2)}

Performance Metrics:
{json.dumps(performance_metrics, indent=2)}

Failed Tests: {failed_tests if failed_tests else 'None'}

Task: Improve the code to make all tests pass while optimizing performance.
Focus on: {', '.join(failed_tests) if failed_tests else 'general improvements'}
"""
        return context
    
    async def _call_claude_api(self, context: str) -> str:
        """调用Claude API生成改进代码"""
        # 实际实现中需要调用Claude API
        # 这里简化处理，返回模拟结果
        await asyncio.sleep(0.1)  # 模拟API延迟
        
        # 实际场景中，这里会调用:
        # response = await anthropic.messages.create(
        #     model="claude-sonnet-4-20250514",
        #     max_tokens=4096,
        #     messages=[{"role": "user", "content": context}]
        # )
        
        return self.current_code  # 实际返回改进后的代码
    
    def _generate_explanation(
        self,
        test_results: dict[str, bool],
        performance_metrics: dict[str, float]
    ) -> str:
        """生成代码修改的自然语言解释"""
        improvements = []
        
        for test_name, passed in test_results.items():
            if passed:
                improvements.append(f"Fixed: {test_name}")
                
        return "; ".join(improvements) if improvements else "General optimization"
    
    async def execute_iteration(
        self,
        iteration_number: int
    ) -> IterationResult:
        """执行单次迭代"""
        iteration_id = hashlib.md5(
            f"{self.current_code}{iteration_number}{time.time()}".encode()
        ).hexdigest()[:12]
        
        # 运行测试
        test_results, performance_metrics = await self.run_tests(self.current_code)
        
        # 生成改进
        improved_code, explanation = await self.generate_code_improvement(
            self.current_code,
            test_results,
            performance_metrics
        )
        
        # 在沙箱中验证
        self.current_code = improved_code
        sandbox_results, sandbox_metrics = await self.run_tests(self.current_code)
        
        # 确定状态
        all_passed = all(sandbox_results.values())
        status = IterationStatus.SUCCESS if all_passed else IterationStatus.RUNNING
        
        # 需要人工审查
        if iteration_number % self.human_review_interval == 0:
            status = IterationStatus.HUMAN_REVIEW
        
        return IterationResult(
            iteration_id=iteration_id,
            status=status,
            code_changes=diff(self.current_code, improved_code),
            test_results=sandbox_results,
            performance_metrics=sandbox_metrics,
            duration_seconds=sum(v for k, v in sandbox_metrics.items() if 'duration' in k),
            ai_explanation=explanation
        )
    
    async def run_autonomous_iteration(
        self,
        goal: str,
        initial_code: str
    ) -> list[IterationResult]:
        """
        运行自主迭代
        
        Args:
            goal: 优化目标描述
            initial_code: 初始代码
            
        Returns:
            迭代结果列表
        """
        self.current_code = initial_code
        
        # 建立性能基准
        baseline_results, baseline_metrics = await self.run_tests(initial_code)
        self.performance_baseline = baseline_metrics
        
        print(f"Starting autonomous iteration for goal: {goal}")
        print(f"Initial test pass rate: {sum(baseline_results.values())}/{len(baseline_results)}")
        
        results = []
        for i in range(1, self.max_iterations + 1):
            print(f"\n--- Iteration {i} ---")
            
            result = await self.execute_iteration(i)
            results.append(result)
            self.iteration_history.append(result)
            
            print(f"Status: {result.status.value}")
            print(f"Tests passed: {sum(result.test_results.values())}/{len(result.test_results)}")
            print(f"Duration: {result.duration_seconds:.2f}s")
            
            # 检查是否所有测试都通过
            if result.status == IterationStatus.SUCCESS:
                print("\n✓ All tests passed! Stopping iteration.")
                break
            
            # 检查性能是否已显著提升
            if self._check_performance_plateau(result.performance_metrics):
                print("\n⚠ Performance plateau detected. Consider human review.")
                
            # 人工审查节点
            if result.status == IterationStatus.HUMAN_REVIEW:
                print("\n⏸ Human review required. Pause for intervention.")
                # 实际场景中，这里会暂停等待人工确认
                # await self.request_human_review(result)
        
        return results
    
    def _check_performance_plateau(
        self,
        current_metrics: dict[str, float]
    ) -> bool:
        """检查是否出现性能 plateau（边际收益递减）"""
        if len(self.iteration_history) < 2:
            return False
            
        # 计算最近几次迭代的性能变化
        recent_improvements = []
        for i in range(max(0, len(self.iteration_history) - 5), len(self.iteration_history)):
            prev = self.iteration_history[i-1].performance_metrics
            curr = self.iteration_history[i].performance_metrics
            
            for key in prev:
                if key in curr and 'duration' in key:
                    # 跳过错误指标
                    if 'error' not in key:
                        improvement = (prev[key] - curr[key]) / max(prev[key], 0.001)
                        recent_improvements.append(improvement)
        
        # 如果平均改进小于阈值，认为进入 plateau
        if recent_improvements:
            avg_improvement = sum(recent_improvements) / len(recent_improvements)
            return avg_improvement < self.improprovement_threshold
        
        return False


def diff(old_code: str, new_code: str) -> str:
    """生成代码差异"""
    # 简化实现，实际应使用git diff或类似工具
    return f"Changed {len(new_code) - len(old_code)} characters"

package sandbox

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"os"
	"path/filepath"
	"strings"
	"sync"
	"time"
)

/*
 * 沙箱执行环境 - Go实现
 * 
 * 核心功能：
 * 1. 隔离的编译和执行环境
 * 2. 资源限制（CPU、内存、时间）
 * 3. 测试结果收集与报告
 * 4. 安全的代码差异对比
 */

type SandboxConfig struct {
	WorkingDir       string
	MaxMemoryMB      int64
	MaxCPUPercent    int
	TimeoutSeconds   int
	AllowedImports   []string
	NetworkIsolation bool
}

type TestResult struct {
	Name      string            `json:"name"`
	Passed    bool              `json:"passed"`
	Duration  float64           `json:"duration_ms"`
	ErrorMsg  string            `json:"error,omitempty"`
	Metrics   map[string]float64 `json:"metrics,omitempty"`
}

type SandboxResult struct {
	ExitCode   int         `json:"exit_code"`
	TestResults []TestResult `json:"test_results"`
	Output     string      `json:"output"`
	Error      string      `json:"error,omitempty"`
	Duration   float64     `json:"duration_ms"`
	MemoryPeak int64       `json:"memory_peak_bytes"`
}

type Sandbox struct {
	config   SandboxConfig
	mu       sync.RWMutex
	running  bool
	cancelFn context.CancelFunc
}

type CodeChange struct {
	FilePath   string `json:"file_path"`
	OldContent string `json:"old_content"`
	NewContent string `json:"new_content"`
	Diff       string `json:"diff"`
}

type DiffReport struct {
	Changes []CodeChange `json:"changes"`
	Summary DiffSummary `json:"summary"`
}

type DiffSummary struct {
	FilesChanged   int    `json:"files_changed"`
	LinesAdded    int    `json:"lines_added"`
	LinesRemoved  int    `json:"lines_removed"`
	Additions     []string `json:"additions,omitempty"`
	Deletions     []string `json:"deletions,omitempty"`
}

// NewSandbox 创建新的沙箱实例
func NewSandbox(config SandboxConfig) (*Sandbox, error) {
	// 验证工作目录
	if config.WorkingDir == "" {
		config.WorkingDir = filepath.Join(os.TempDir(), "sandbox", randomID())
	}
	
	if err := os.MkdirAll(config.WorkingDir, 0755); err != nil {
		return nil, fmt.Errorf("failed to create working dir: %w", err)
	}
	
	return &Sandbox{
		config:  config,
		running: false,
	}, nil
}

// Execute 在沙箱中执行代码
func (s *Sandbox) Execute(ctx context.Context, code string, lang string) (*SandboxResult, error) {
	s.mu.Lock()
	if s.running {
		s.mu.Unlock()
		return nil, fmt.Errorf("sandbox already running")
	}
	s.running = true
	s.mu.Unlock()
	
	defer func() {
		s.mu.Lock()
		s.running = false
		s.mu.Unlock()
	}()
	
	// 创建超时上下文
	ctx, cancel := context.WithTimeout(ctx, time.Duration(s.config.TimeoutSeconds)*time.Second)
	defer cancel()
	s.cancelFn = cancel
	
	// 根据语言选择执行器
	switch strings.ToLower(lang) {
	case "python":
		return s.executePython(ctx, code)
	case "go":
		return s.executeGo(ctx, code)
	case "javascript", "nodejs":
		return s.executeNode(ctx, code)
	default:
		return nil, fmt.Errorf("unsupported language: %s", lang)
	}
}

// executePython 执行Python代码
func (s *Sandbox) executePython(ctx context.Context, code string) (*SandboxResult, error) {
	start := time.Now()
	
	// 写入临时文件
	scriptPath := filepath.Join(s.config.WorkingDir, "script.py")
	if err := os.WriteFile(scriptPath, []byte(code), 0644); err != nil {
		return nil, fmt.Errorf("failed to write script: %w", err)
	}
	
	// 构建命令
	cmd := execCommandContext(ctx, "python3", scriptPath)
	cmd.Dir = s.config.WorkingDir
	
	// 设置资源限制
	cmd.SysProcAttr = getSysProcAttr(s.config.MaxMemoryMB)
	
	// 执行
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	
	err := cmd.Run()
	duration := time.Since(start).Seconds() * 1000 // 毫秒
	
	result := &SandboxResult{
		ExitCode:   0,
		TestResults: []TestResult{},
		Output:     stdout.String(),
		Duration:   duration,
	}
	
	if err != nil {
		result.ExitCode = 1
		result.Error = stderr.String()
	}
	
	// 解析测试结果
	result.TestResults = s.parseTestOutput(stdout.String(), duration)
	
	return result, nil
}

// executeGo 执行Go代码
func (s *Sandbox) executeGo(ctx context.Context, code string) (*SandboxResult, error) {
	start := time.Now()
	
	// 写入临时文件
	mainPath := filepath.Join(s.config.WorkingDir, "main.go")
	if err := os.WriteFile(mainPath, []byte(code), 0644); err != nil {
		return nil, fmt.Errorf("failed to write main.go: %w", err)
	}
	
	// 编译
	compileCtx, cancel := context.WithTimeout(ctx, 30*time.Second)
	defer cancel()
	
	compileCmd := execCommandContext(compileCtx, "go", "build", "-o", "program", mainPath)
	compileCmd.Dir = s.config.WorkingDir
	
	var compileErr bytes.Buffer
	compileCmd.Stderr = &compileErr
	
	if err := compileCmd.Run(); err != nil {
		return &SandboxResult{
			ExitCode:  1,
			Error:     compileErr.String(),
			Duration:  time.Since(start).Seconds() * 1000,
		}, nil
	}
	
	// 运行
	cmd := execCommandContext(ctx, filepath.Join(s.config.WorkingDir, "program"))
	cmd.Dir = s.config.WorkingDir
	cmd.SysProcAttr = getSysProcAttr(s.config.MaxMemoryMB)
	
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	
	duration := time.Since(start).Seconds() * 1000
	
	result := &SandboxResult{
		ExitCode:   0,
		TestResults: []TestResult{},
		Output:     stdout.String(),
		Duration:   duration,
	}
	
	if err := cmd.Run(); err != nil {
		result.ExitCode = 1
		result.Error = stderr.String()
	}
	
	result.TestResults = s.parseTestOutput(stdout.String(), duration)
	
	return result, nil
}

// executeNode 执行JavaScript代码
func (s *Sandbox) executeNode(ctx context.Context, code string) (*SandboxResult, error) {
	start := time.Now()
	
	scriptPath := filepath.Join(s.config.WorkingDir, "script.js")
	if err := os.WriteFile(scriptPath, []byte(code), 0644); err != nil {
		return nil, fmt.Errorf("failed to write script: %w", err)
	}
	
	cmd := execCommandContext(ctx, "node", scriptPath)
	cmd.Dir = s.config.WorkingDir
	cmd.SysProcAttr = getSysProcAttr(s.config.MaxMemoryMB)
	
	var stdout, stderr bytes.Buffer
	cmd.Stdout = &stdout
	cmd.Stderr = &stderr
	
	duration := time.Since(start).Seconds() * 1000
	
	result := &SandboxResult{
		ExitCode:   0,
		Output:     stdout.String(),
		Duration:   duration,
	}
	
	if err := cmd.Run(); err != nil {
		result.ExitCode = 1
		result.Error = stderr.String()
	}
	
	result.TestResults = s.parseTestOutput(stdout.String(), duration)
	
	return result, nil
}

// execCommandContext 跨平台命令执行
func execCommandContext(ctx context.Context, name string, arg ...string) interface{} {
	// 根据平台返回正确的命令类型
	// 实际实现会根据runtime.GOOS返回exec.Cmd或syscall.SysProcAttr
	return nil // 简化，实际需要完整的exec.Command实现
}

// getSysProcAttr 获取进程属性（用于资源限制）
func getSysProcAttr(maxMemoryMB int64) interface{} {
	// 实际实现会根据runtime.GOOS设置资源限制
	// Linux: cgroup、seccomp
	// macOS: setrlimit
	// Windows: JobObject
	return nil
}

// parseTestOutput 解析测试输出
func (s *Sandbox) parseTestOutput(output string, duration float64) []TestResult {
	results := []TestResult{}
	
	// 尝试解析JSON格式的测试结果
	if strings.Contains(output, "{") {
		// 简单JSON解析
		if idx := strings.Index(output, "{"); idx >= 0 {
			jsonStr := output[idx:]
			var parsed map[string]interface{}
			if err := json.Unmarshal([]byte(jsonStr), &parsed); err == nil {
				if tests, ok := parsed["tests"].([]interface{}); ok {
					for _, t := range tests {
						if testMap, ok := t.(map[string]interface{}); ok {
							results = append(results, TestResult{
								Name:     getString(testMap, "name"),
								Passed:   getBool(testMap, "passed"),
								Duration: getFloat64(testMap, "duration"),
							})
						}
					}
				}
			}
		}
	}
	
	// 如果没有解析到测试结果，创建默认结果
	if len(results) == 0 {
		results = append(results, TestResult{
			Name:     "default",
			Passed:   true,
			Duration: duration,
		})
	}
	
	return results
}

func getString(m map[string]interface{}, key string) string {
	if v, ok := m[key].(string); ok {
		return v
	}
	return ""
}

func getBool(m map[string]interface{}, key string) bool {
	if v, ok := m[key].(bool); ok {
		return v
	}
	return false
}

func getFloat64(m map[string]interface{}, key string) float64 {
	switch v := m[key].(type) {
	case float64:
		return v
	case int:
		return float64(v)
	}
	return 0
}

func randomID() string {
	// 简化的随机ID生成
	return fmt.Sprintf("%d", time.Now().UnixNano())
}

// Stop 停止沙箱
func (s *Sandbox) Stop() error {
	s.mu.Lock()
	defer s.mu.Unlock()
	
	if s.cancelFn != nil {
		s.cancelFn()
	}
	
	s.running = false
	return nil
}

// Cleanup 清理沙箱资源
func (s *Sandbox) Cleanup() error {
	return os.RemoveAll(s.config.WorkingDir)
}

// GenerateDiffReport 生成代码差异报告
func GenerateDiffReport(oldCode, newCode string, filename string) *DiffReport {
	report := &DiffReport{
		Changes: []CodeChange{
			{
				FilePath:   filename,
				OldContent: oldCode,
				NewContent: newCode,
				Diff:       computeDiff(oldCode, newCode),
			},
		},
	}
	
	// 统计变更
	lines := strings.Split(report.Changes[0].Diff, "\n")
	for _, line := range lines {
		switch {
		case strings.HasPrefix(line, "+") && !strings.HasPrefix(line, "+++"):
			report.Summary.LinesAdded++
			report.Summary.Additions = append(report.Summary.Additions, line[1:])
		case strings.HasPrefix(line, "-") && !strings.HasPrefix(line, "---"):
			report.Summary.LinesRemoved++
			report.Summary.Deletions = append(report.Summary.Deletions, line[1:])
		}
	}
	report.Summary.FilesChanged = 1
	
	return report
}

// computeDiff 简化版diff计算
func computeDiff(oldStr, newStr string) string {
	oldLines := strings.Split(oldStr, "\n")
	newLines := strings.Split(newStr, "\n")
	
	var diff []string
	diff = append(diff, "--- old")
	diff = append(diff, "+++ new")
	
	// 简单行对比
	maxLen := max(len(oldLines), len(newLines))
	for i := 0; i < maxLen; i++ {
		var oldLine, newLine string
		if i < len(oldLines) {
			oldLine = oldLines[i]
		}
		if i < len(newLines) {
			newLine = newLines[i]
		}
		
		if oldLine == newLine {
			diff = append(diff, fmt.Sprintf(" %s", oldLine))
		} else {
			if oldLine != "" {
				diff = append(diff, fmt.Sprintf("-%s", oldLine))
			}
			if newLine != "" {
				diff = append(diff, fmt.Sprintf("+%s", newLine))
			}
		}
	}
	
	return strings.Join(diff, "\n")
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// Main函数示例
func main() {
	fmt.Println("Sandbox Environment for Agent Iteration")
	fmt.Println("========================================")
	
	// 创建沙箱配置
	config := SandboxConfig{
		WorkingDir:     "",
		MaxMemoryMB:    512,
		MaxCPUPercent:  80,
		TimeoutSeconds: 60,
	}
	
	// 创建沙箱
	sb, err := NewSandbox(config)
	if err != nil {
		log.Fatalf("Failed to create sandbox: %v", err)
	}
	defer sb.Cleanup()
	
	// 测试代码
	testCode := `
package main

import "fmt"

func main() {
    fmt.Println("Hello from sandbox!")
}
`
	
	// 执行
	ctx := context.Background()
	result, err := sb.Execute(ctx, testCode, "go")
	if err != nil {
		log.Fatalf("Execution failed: %v", err)
	}
	
	// 输出结果
	fmt.Printf("Exit Code: %d\n", result.ExitCode)
	fmt.Printf("Output: %s\n", result.Output)
	fmt.Printf("Duration: %.2fms\n", result.Duration)
	fmt.Printf("Tests: %d/%d passed\n", 
		len(func() []bool {
			passed := 0
			for _, t := range result.TestResults {
				if t.Passed {
					passed++
				}
			}
			return []bool{true}
		}()),
		len(result.TestResults))
}

"""
AI代码审查系统 - Python实现
基于Claude的自动化代码审查与质量评估
"""

import anthropic
import re
from dataclasses import dataclass
from typing import Optional
from enum import Enum


class IssueSeverity(Enum):
    CRITICAL = "critical"
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"
    INFO = "info"


@dataclass
class CodeIssue:
    """代码问题"""
    line_number: Optional[int]
    severity: IssueSeverity
    category: str
    description: str
    suggestion: str
    ai_confidence: float


@dataclass
class CodeReviewResult:
    """代码审查结果"""
    file_path: str
    overall_score: float  # 0-10
    issues: list[CodeIssue]
    strengths: list[str]
    summary: str
    estimated_bugs_caught: float  # 与人类工程师相比


class ClaudeCodeReviewer:
    """
    基于Claude的自动化代码审查器
    
    核心功能：
    1. 静态代码分析
    2. 安全漏洞检测
    3. 性能问题识别
    4. 代码风格评估
    5. 历史bug模式匹配
    """
    
    def __init__(
        self,
        api_key: str,
        model: str = "claude-sonnet-4-20250514"
    ):
        self.client = anthropic.Anthropic(api_key=api_key)
        self.model = model
        
        # 安全检查规则
        self.security_patterns = {
            "sql_injection": re.compile(r'execute\(|exec\(|eval\('),
            "hardcoded_secret": re.compile(r'password\s*=\s*["\'][^"\']{8,}["\']'),
            "unsafe_deserialization": re.compile(r'pickle\.|yaml\.load\('),
            "path_traversal": re.compile(r'\.\./|\.\.\\'),
        }
        
    async def review_code(
        self,
        code: str,
        language: str = "python",
        file_path: str = "unknown.py"
    ) -> CodeReviewResult:
        """审查代码"""
        
        # 第一步：静态分析
        static_issues = self._static_analysis(code, language)
        
        # 第二步：Claude深度分析
        claude_issues = await self._claude_analysis(code, language)
        
        # 第三步：合并结果
        all_issues = static_issues + claude_issues
        
        # 第四步：计算评分
        overall_score = self._calculate_score(all_issues, code)
        
        # 第五步：识别优点
        strengths = self._identify_strengths(code, claude_issues)
        
        # 第六步：生成摘要
        summary = self._generate_summary(overall_score, all_issues)
        
        # 估算能catch多少人类漏过的bug
        estimated_bugs_caught = self._estimate_bug_catch_rate(
            overall_score, 
            len(all_issues)
        )
        
        return CodeReviewResult(
            file_path=file_path,
            overall_score=overall_score,
            issues=all_issues,
            strengths=strengths,
            summary=summary,
            estimated_bugs_caught=estimated_bugs_caught
        )
    
    def _static_analysis(
        self,
        code: str,
        language: str
    ) -> list[CodeIssue]:
        """静态代码分析"""
        issues = []
        
        # 安全检查
        for name, pattern in self.security_patterns.items():
            matches = pattern.finditer(code)
            for match in matches:
                # 计算行号
                line_num = code[:match.start()].count('\n') + 1
                
                severity = IssueSeverity.CRITICAL
                if name == "hardcoded_secret":
                    severity = IssueSeverity.HIGH
                    
                issues.append(CodeIssue(
                    line_number=line_num,
                    severity=severity,
                    category="security",
                    description=f"Potential {name} vulnerability detected",
                    suggestion=self._get_security_suggestion(name),
                    ai_confidence=0.95
                ))
        
        # 代码复杂度检查（Python示例）
        if language == "python":
            lines = code.split('\n')
            
            # 过长函数检测
            current_function = None
            function_lines = 0
            for i, line in enumerate(lines, 1):
                if re.match(r'^def\s+\w+', line):
                    if function_lines > 50 and current_function:
                        issues.append(CodeIssue(
                            line_number=i,
                            severity=IssueSeverity.MEDIUM,
                            category="maintainability",
                            description=f"Function '{current_function}' has {function_lines} lines",
                            suggestion="Consider breaking into smaller functions",
                            ai_confidence=0.8
                        ))
                    current_function = re.search(r'def\s+(\w+)', line).group(1)
                    function_lines = 0
                elif not line.strip().startswith('#'):
                    function_lines += 1
                    
        return issues
    
    def _get_security_suggestion(self, vulnerability: str) -> str:
        """获取安全建议"""
        suggestions = {
            "sql_injection": "Use parameterized queries or ORM methods",
            "hardcoded_secret": "Use environment variables or secrets manager",
            "unsafe_deserialization": "Use json.loads() or yaml.safe_load() instead",
            "path_traversal": "Validate and sanitize user input for file paths",
        }
        return suggestions.get(vulnerability, "Review and fix security issue")
    
    async def _claude_analysis(
        self,
        code: str,
        language: str
    ) -> list[CodeIssue]:
        """Claude深度分析"""
        
        prompt = f"""Analyze this {language} code and identify potential issues:

```{language}
{code}