"""
非对称PPO架构实现
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import List, Tuple

class AsymmetricPPO(nn.Module):
    """
    非对称PPO：执行时只用环境信息，训练时用完整轨迹
    """
    
    def __init__(self, 
                 action_dim: int,
                 obs_dim: int,
                 hidden_dim: int = 1024,
                 trajectory_dim: int = 2048):
        super().__init__()
        
        # 执行策略网络（仅看当前观测）
        self.actor = nn.Sequential(
            nn.Linear(obs_dim, hidden_dim),
            nn.GELU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.GELU(),
            nn.Linear(hidden_dim, action_dim)
        )
        
        # 训练价值网络（看完整轨迹上下文）
        self.critic = nn.Sequential(
            nn.Linear(trajectory_dim, hidden_dim),
            nn.GELU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.GELU(),
            nn.Linear(hidden_dim, 1)
        )
        
        # 执行编码器（仅编码当前观测）
        self.online_encoder = nn.Sequential(
            nn.Linear(obs_dim, hidden_dim),
            nn.GELU(),
            nn.Linear(hidden_dim, hidden_dim)
        )
        
        # 训练编码器（编码完整轨迹）
        self.trajectory_encoder = nn.Sequential(
            nn.Linear(trajectory_dim, hidden_dim * 2),
            nn.GELU(),
            nn.Linear(hidden_dim * 2, hidden_dim)
        )
    
    def get_action(self, obs: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
        """
        执行时：仅基于当前观测输出动作
        """
        features = self.online_encoder(obs)
        logits = self.actor(features)
        probs = F.softmax(logits, dim=-1)
        dist = torch.distributions.Categorical(probs)
        action = dist.sample()
        log_prob = dist.log_prob(action)
        return action, log_prob
    
    def compute_advantage(self, 
                          trajectory: torch.Tensor,
                          rewards: torch.Tensor,
                          gamma: float = 0.99,
                          gae_lambda: float = 0.95) -> torch.Tensor:
        """
        训练时：基于完整轨迹计算GAE优势
        """
        trajectory_features = self.trajectory_encoder(trajectory)
        values = self.critic(trajectory_features).squeeze(-1)
        
        # GAE计算
        advantages = []
        gae = 0
        next_value = 0
        
        for t in reversed(range(len(rewards))):
            delta = rewards[t] + gamma * next_value - values[t]
            gae = delta + gamma * gae_lambda * gae
            advantages.insert(0, gae)
            next_value = values[t].item() if values.dim() > 0 else values[t]
        
        return torch.tensor(advantages)

# 模拟训练过程
def simulate_training():
    print("=== 非对称PPO训练过程模拟 ===")
    print("\n执行阶段（每秒10次）：")
    print("  Step 1: 分析仓库结构 → 定位到 src/models/checkout.go")
    print("  Step 2: 读取现有代码 → 理解优惠券叠加逻辑")
    print("  Step 3: 修改价格计算函数 → 添加叠加校验")
    print("  Step 4: 运行测试用例 → 测试失败（边界条件未覆盖）")
    print("  Step 5: 查看测试失败信息 → 定位到缺失的折扣上限检查")
    print("  Step 6: 修复代码 → 添加折扣上限校验")
    print("  Step 7: 重新运行测试 → 全部通过 ✅")
    print("  Step 8: 生成commit → 任务完成")
    
    print("\n训练阶段（GAE优势计算）：")
    print("  奖励信号分解：")
    print("    - 每成功定位一个文件: +0.1")
    print("    - 测试通过: +1.0")
    print("    - 一次通过（无需修复）：+0.5 bonus")
    print("    - 失败后自主修复：+0.3 bonus")
    print("    - 使用合理工具调用：+0.05/tool")
    print("    - 不规范行为（如rm -rf）：-0.2")
    print("\n  分层奖励机制：")
    print("    核心层：任务完成度（0-1.0）")
    print("    规范层：工具使用规范性（0-0.3）")
    print("    探索层：失败轨迹激励（0-0.2）")

simulate_training()

"""
数据飞轮与失败轨迹利用分析
"""
import numpy as np

class DataFlywheel:
    def __init__(self):
        self.total_attempts = 10000
        self.build_success_rate = 0.165  # 行业平均
        self.near_miss_rate = 0.20  # 差一步成功的比例
        self.recovery_rate = 0.60  # 针对提示重新执行的成功率
        
    def analyze_flywheel(self):
        print("=" * 70)
        print("数据飞轮效果分析")
        print("=" * 70)
        
        # 初始状态
        initial_success = self.total_attempts * self.build_success_rate
        initial_fail = self.total_attempts - initial_success
        near_misses = initial_fail * self.near_miss_rate
        recovered = near_misses * self.recovery_rate
        
        final_success = initial_success + recovered
        final_rate = final_success / self.total_attempts
        
        print(f"\n初始状态：")
        print(f"  总尝试: {self.total_attempts}")
        print(f"  初始构建成功率: {self.build_success_rate:.1%}")
        print(f"  初始成功数: {initial_success:.0f}")
        print(f"  初始失败数: {initial_fail:.0f}")
        
        print(f"\n失败轨迹利用：")
        print(f"  差一步成功: {near_misses:.0f} ({self.near_miss_rate:.0%} of failures)")
        print(f"  针对性提示后恢复: {recovered:.0f} ({self.recovery_rate:.0%} recovery)")
        
        print(f"\n最终状态：")
        print(f"  最终成功数: {final_success:.0f}")
        print(f"  最终成功率: {final_rate:.1%}")
        print(f"  提升: +{final_rate - self.build_success_rate:.1%}")
        
        # 迭代收敛
        print(f"\n迭代收敛分析：")
        rate = self.build_success_rate
        for i in range(5):
            new_rate = self.iterate(rate)
            print(f"  Round {i+1}: {rate:.1%} → {new_rate:.1%}")
            rate = new_rate
            
    def iterate(self, current_rate):
        fail = 1 - current_rate
        near_miss = fail * self.near_miss_rate
        recovered = near_miss * self.recovery_rate
        return current_rate + recovered / 1  # 归一化

flywheel = DataFlywheel()
flywheel.analyze_flywheel()

package main

import (
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
	"sync"
	"time"
)

// 语言配置
type LanguageConfig struct {
	Name          string
	DependencyFile string
	BuildCmd      string
	TestCmd       string
	VersionCmd    string
}

var languageConfigs = map[string]LanguageConfig{
	"go": {
		Name:           "Go",
		DependencyFile: "go.mod",
		BuildCmd:       "go build ./...",
		TestCmd:        "go test ./...",
		VersionCmd:     "go version",
	},
	"python": {
		Name:           "Python",
		DependencyFile: "requirements.txt",
		BuildCmd:       "pip install -r requirements.txt",
		TestCmd:        "pytest",
		VersionCmd:     "python --version",
	},
	"javascript": {
		Name:           "JavaScript",
		DependencyFile: "package.json",
		BuildCmd:       "npm install",
		TestCmd:        "npm test",
		VersionCmd:     "node --version",
	},
	"rust": {
		Name:           "Rust",
		DependencyFile: "Cargo.toml",
		BuildCmd:       "cargo build",
		TestCmd:        "cargo test",
		VersionCmd:     "rustc --version",
	},
	"java": {
		Name:           "Java",
		DependencyFile: "pom.xml",
		BuildCmd:       "mvn compile",
		TestCmd:        "mvn test",
		VersionCmd:     "java -version",
	},
}

// 仓库环境
type RepoEnvironment struct {
	Path       string          `json:"path"`
	Language   string          `json:"language"`
	Config     LanguageConfig  `json:"-"`
	BuildLog   string          `json:"build_log"`
	TestLog    string          `json:"test_log"`
	BuildOK    bool            `json:"build_ok"`
	TestOK     bool            `json:"test_ok"`
	ErrorCount int             `json:"error_count"`
}

// AutoBuilder 引擎
type AutoBuilder struct {
	mu            sync.Mutex
	workDir       string
	successCount  int
	totalCount    int
	recoveredCount int
}

func NewAutoBuilder(workDir string) *AutoBuilder {
	return &AutoBuilder{
		workDir: workDir,
	}
}

// 检测仓库语言
func (ab *AutoBuilder) detectLanguage(repoPath string) (string, error) {
	for lang, cfg := range languageConfigs {
		depPath := filepath.Join(repoPath, cfg.DependencyFile)
		if _, err := os.Stat(depPath); err == nil {
			return lang, nil
		}
	}
	return "", fmt.Errorf("unsupported language in %s", repoPath)
}

// 生成构建配置
func (ab *AutoBuilder) generateBuildScript(repo *RepoEnvironment) (string, error) {
	script := fmt.Sprintf(`#!/bin/bash
# Auto-generated build script for %s project
set -e

cd "%s"

# 安装依赖
echo "=== Installing dependencies ==="
%s

# 构建
echo "=== Building ==="
%s

# 测试
echo "=== Running tests ==="
%s
`, repo.Language, repo.Path, repo.Config.BuildCmd, repo.Config.BuildCmd, repo.Config.TestCmd)

	scriptPath := filepath.Join(repo.Path, ".autobuild.sh")
	err := os.WriteFile(scriptPath, []byte(script), 0755)
	return scriptPath, err
}

// 构建仓库环境
func (ab *AutoBuilder) BuildRepo(repoPath string) (*RepoEnvironment, error) {
	lang, err := ab.detectLanguage(repoPath)
	if err != nil {
		return nil, err
	}

	config := languageConfigs[lang]
	repo := &RepoEnvironment{
		Path:     repoPath,
		Language: lang,
		Config:   config,
	}

	// 生成构建脚本
	scriptPath, err := ab.generateBuildScript(repo)
	if err != nil {
		return repo, err
	}

	// 执行构建
	start := time.Now()
	cmd := exec.Command("bash", scriptPath)
	cmd.Dir = repoPath
	output, err := cmd.CombinedOutput()
	repo.BuildLog = string(output)
	repo.BuildOK = err == nil

	// 检查测试结果
	repo.TestOK = strings.Contains(repo.BuildLog, "PASS") || 
	              strings.Contains(repo.BuildLog, "OK") ||
	              strings.Contains(repo.BuildLog, "All tests passed")

	// 统计错误
	repo.ErrorCount = strings.Count(repo.BuildLog, "FAIL") + 
	                  strings.Count(repo.BuildLog, "ERROR")

	ab.mu.Lock()
	ab.totalCount++
	if repo.BuildOK && repo.TestOK {
		ab.successCount++
	}
	ab.mu.Unlock()

	fmt.Printf("[AutoBuilder] %s: build=%v, test=%v, errors=%d, time=%v\n",
		filepath.Base(repoPath), repo.BuildOK, repo.TestOK, 
		repo.ErrorCount, time.Since(start))

	return repo, nil
}

// 失败轨迹恢复
func (ab *AutoBuilder) RecoverFromFailure(repo *RepoEnvironment) (*RepoEnvironment, bool) {
	if repo.BuildOK {
		return repo, true
	}

	// 分析失败原因
	failures := analyzeFailure(repo.BuildLog)
	if len(failures) == 0 {
		return repo, false
	}

	// 生成修复提示
	prompt := generateFixPrompt(repo, failures)
	fmt.Printf("[AutoBuilder] Recovery attempt: %s\n", prompt)

	// 重新执行（简化版）
	rebuilt, err := ab.BuildRepo(repo.Path)
	if err != nil {
		return repo, false
	}

	ab.mu.Lock()
	if rebuilt.BuildOK && rebuilt.TestOK {
		ab.recoveredCount++
	}
	ab.mu.Unlock()

	return rebuilt, rebuilt.BuildOK && rebuilt.TestOK
}

func analyzeFailure(log string) []string {
	var failures []string
	if strings.Contains(log, "not found") {
		failures = append(failures, "missing_dependency")
	}
	if strings.Contains(log, "syntax error") {
		failures = append(failures, "syntax_error")
	}
	if strings.Contains(log, "version conflict") {
		failures = append(failures, "version_conflict")
	}
	if strings.Contains(log, "permission denied") {
		failures = append(failures, "permission_error")
	}
	return failures
}

func generateFixPrompt(repo *RepoEnvironment, failures []string) string {
	return fmt.Sprintf("Fix %s project build: %s", repo.Language, strings.Join(failures, ", "))
}

// 统计报告
func (ab *AutoBuilder) Report() {
	ab.mu.Lock()
	defer ab.mu.Unlock()

	fmt.Println("\n=== AutoBuilder Performance Report ===")
	fmt.Printf("Total repos attempted: %d\n", ab.totalCount)
	fmt.Printf("Successful builds: %d\n", ab.successCount)
	fmt.Printf("Recovered from failures: %d\n", ab.recoveredCount)
	
	successRate := float64(ab.successCount) / float64(ab.totalCount) * 100
	recoveryRate := float64(ab.recoveredCount) / float64(ab.totalCount) * 100
	effectiveRate := float64(ab.successCount+ab.recoveredCount) / float64(ab.totalCount) * 100
	
	fmt.Printf("Initial success rate: %.1f%%\n", successRate)
	fmt.Printf("Recovery rate: %.1f%%\n", recoveryRate)
	fmt.Printf("Effective success rate: %.1f%%\n", effectiveRate)
}

func main() {
	builder := NewAutoBuilder("/tmp/autobuild")
	
	// 模拟多个仓库构建
	repos := []string{
		"/tmp/repos/go-webapp",
		"/tmp/repos/python-ml",
		"/tmp/repos/js-frontend",
	}
	
	for _, repo := range repos {
		env, err := builder.BuildRepo(repo)
		if err != nil {
			fmt.Printf("Build failed: %v\n", err)
			continue
		}
		
		// 尝试恢复失败轨迹
		if !env.BuildOK || !env.TestOK {
			builder.RecoverFromFailure(env)
		}
	}
	
	builder.Report()
}