// UMD 模式可以同时支持多种加载方式
// 1. AMD (RequireJS)
// 2. CommonJS (Node.js)
// 3. 全局变量 (浏览器直接引入)
(function (root, factory) {
    if (typeof define === 'function' && define.amd) {
        define([], factory); // AMD
    } else if (typeof module === 'object' && module.exports) {
        module.exports = factory(); // CommonJS
    } else {
        root.AIAgent = factory(); // 全局变量
    }
}(typeof self !== 'undefined' ? self : this, function () {
    // 插件代码
}));

// webpack.config.js
output: {
  filename: 'ai-agent.js',
  path: path.resolve(__dirname, 'dist'),
  library: {
    name: 'AIAgent',
    type: 'umd',
    export: 'default'
  },
  globalObject: 'this'
}

new AIAgent({
  theme: 'light'  // 或 'dark'
});

new AIAgent({
  theme: 'light',
  colors: {
    primary: '#ff6b6b',      // 主色调
    background: '#f0f0f0',   // 背景色
    text: '#2c3e50'          // 文本颜色
  }
});

new AIAgent({
  colors: {
    primary: '#ff6b6b',
    primaryHover: '#ff5252',
    background: '#f0f0f0',
    text: '#2c3e50',
    border: '#e0e0e0',
    aiMessageBg: '#e8f5e9',
    userMessageBg: '#ff6b6b',
    headerBg: '#fafafa'
  }
});

// webpack.config.js
module.exports = [
  // 1. UMD 格式（未压缩）
  {
    output: {
      filename: 'ai-agent.js',
      library: { name: 'AIAgent', type: 'umd' }
    }
  },
  // 2. UMD 格式（压缩）
  {
    output: {
      filename: 'ai-agent.min.js',
      library: { name: 'AIAgent', type: 'umd' }
    },
    optimization: {
      minimize: true,
      minimizer: [new TerserPlugin()]
    }
  },
  // 3. ESM 格式（现代构建工具）
  {
    output: {
      filename: 'ai-agent.esm.js',
      library: { type: 'module' }
    },
    experiments: {
      outputModule: true
    }
  }
];

module: {
  rules: [
    {
      test: /\.ts$/,
      use: 'ts-loader',
      exclude: /node_modules/
    }
  ]
}

// postcss.config.js
module.exports = {
  plugins: [
    require('postcss-custom-properties')({
      preserve: false  // 移除 CSS 变量，只保留回退值
    })
  ]
};

async function executeAgent(goal) {
  // 1. 理解目标
  const analysis = await llm.analyze(goal);
  
  // 2. 制定计划
  const plan = await planner.createPlan(analysis);
  
  // 3. 执行步骤
  for (const step of plan.steps) {
    // 3.1 选择合适的工具
    const tool = selectTool(step.action);
    
    // 3.2 执行动作
    const result = await executor.execute(tool, step.params);
    
    // 3.3 评估结果
    if (!result.success) {
      // 重新规划或调整策略
      await planner.replan(result.error);
    }
    
    // 3.4 更新记忆
    memory.store(step, result);
  }
  
  // 4. 返回最终结果
  return summarizeResults();
}

// ChatGPT 工具调用（有限）
const tools = [
  'web_browser',
  'code_interpreter', 
  'dalle_image_generator'
];

// AI Agent 工具调用（可扩展）
const tools = [
  // 信息获取
  'web_search',
  'database_query',
  'api_call',
  'file_read',
  
  // 内容生成
  'code_generator',
  'image_generator',
  'document_writer',
  
  // 操作执行
  'file_system',
  'email_sender',
  'task_scheduler',
  'git_operations',
  
  // 数据处理
  'data_analyzer',
  'chart_generator',
  'ml_predictor',
  
  // 通过 MCP 扩展更多...
];

// 持久化记忆系统
const memory = {
  // 用户偏好
  preferences: {
    codingStyle: 'functional',
    language: 'TypeScript',
    framework: 'React'
  },
  
  // 历史任务
  taskHistory: [
    {
      date: '2026-03-01',
      task: '创建 API 服务',
      solution: '使用 Express + TypeScript',
      success: true
    }
  ],
  
  // 上下文知识
  projectContext: {
    structure: 'monorepo',
    testFramework: 'Jest',
    cicd: 'GitHub Actions'
  }
};

// Agent 利用记忆优化行为
async function createNewService(name) {
  // 自动应用用户偏好
  const template = memory.preferences.language === 'TypeScript' 
    ? 'typescript-service-template'
    : 'javascript-service-template';
    
  // 参考历史成功经验
  const bestPractice = memory.taskHistory
    .filter(t => t.success && t.task.includes('API'))
    .map(t => t.solution);
    
  // 适配项目环境
  const config = generateConfig(memory.projectContext);
  
  return buildService(name, template, bestPractice, config);
}

class SimpleAgent {
  constructor(llm, tools) {
    this.llm = llm;              // 大语言模型
    this.tools = tools;          // 工具集
    this.memory = [];            // 记忆系统
    this.maxSteps = 10;          // 最大步骤数
  }
  
  async execute(goal) {
    console.log(`🎯 目标: ${goal}`);
    
    // 添加目标到记忆
    this.memory.push({
      role: 'user',
      content: goal
    });
    
    let step = 0;
    
    while (step < this.maxSteps) {
      step++;
      console.log(`\n[Step ${step}/${this.maxSteps}]`);
      
      // 1. 让 LLM 决定下一步动作
      const decision = await this.decide();
      
      // 2. 如果认为任务已完成
      if (decision.action === 'finish') {
        console.log('✅ 任务完成！');
        return decision.result;
      }
      
      // 3. 执行工具
      const tool = this.tools[decision.action];
      if (!tool) {
        console.log(`❌ 工具 ${decision.action} 不存在`);
        continue;
      }
      
      console.log(`🔧 执行工具: ${decision.action}`);
      console.log(`📝 参数: ${JSON.stringify(decision.args)}`);
      
      try {
        const result = await tool.execute(decision.args);
        console.log(`✓ 结果: ${JSON.stringify(result).slice(0, 100)}...`);
        
        // 4. 将结果添加到记忆
        this.memory.push({
          role: 'tool',
          tool: decision.action,
          result: result
        });
      } catch (error) {
        console.log(`❌ 执行失败: ${error.message}`);
        this.memory.push({
          role: 'tool',
          tool: decision.action,
          error: error.message
        });
      }
    }
    
    throw new Error('超过最大步骤数');
  }
  
  async decide() {
    // 构建 prompt
    const prompt = this.buildPrompt();
    
    // 调用 LLM
    const response = await this.llm.generate(prompt);
    
    // 解析 LLM 的决策
    return this.parseDecision(response);
  }
  
  buildPrompt() {
    const toolDescriptions = Object.entries(this.tools)
      .map(([name, tool]) => `- ${name}: ${tool.description}`)
      .join('\n');
    
    return `
你是一个 AI Agent，可以使用以下工具：

${toolDescriptions}

对话历史：
${this.memory.map(m => `${m.role}: ${JSON.stringify(m)}`).join('\n')}

请分析当前情况，决定下一步行动。

如果任务已完成，返回：
{
  "action": "finish",
  "result": "最终结果描述"
}

如果需要使用工具，返回：
{
  "action": "工具名称",
  "args": { "参数": "值" },
  "reason": "为什么使用这个工具"
}

你的决策（JSON格式）：
`;
  }
  
  parseDecision(response) {
    // 提取 JSON
    const jsonMatch = response.match(/\{[\s\S]*\}/);
    if (!jsonMatch) {
      throw new Error('无法解析 LLM 响应');
    }
    
    return JSON.parse(jsonMatch[0]);
  }
}

// 定义工具
const tools = {
  search_web: {
    description: '搜索网页内容',
    execute: async (args) => {
      // 实现网页搜索
      const results = await fetch(`https://api.search.com?q=${args.query}`);
      return results.json();
    }
  },
  
  read_file: {
    description: '读取文件内容',
    execute: async (args) => {
      const fs = require('fs').promises;
      return await fs.readFile(args.path, 'utf-8');
    }
  },
  
  write_file: {
    description: '写入文件',
    execute: async (args) => {
      const fs = require('fs').promises;
      await fs.writeFile(args.path, args.content);
      return { success: true };
    }
  },
  
  run_code: {
    description: '执行 Python 代码',
    execute: async (args) => {
      // 使用代码执行器
      const result = await runPython(args.code);
      return result;
    }
  }
};

// 使用示例
const agent = new SimpleAgent(llm, tools);

await agent.execute(
  '搜索今天的天气，然后创建一个 weather.txt 文件保存结果'
);

// 输出：
// 🎯 目标: 搜索今天的天气，然后创建一个 weather.txt 文件保存结果
// 
// [Step 1/10]
// 🔧 执行工具: search_web
// 📝 参数: {"query":"今天天气"}
// ✓ 结果: {"temperature": "22°C", "condition": "晴天"}...
// 
// [Step 2/10]
// 🔧 执行工具: write_file
// 📝 参数: {"path":"weather.txt","content":"今天天气：22°C，晴天"}
// ✓ 结果: {"success":true}
// 
// [Step 3/10]
// ✅ 任务完成！

// MCP Server 为 Agent 提供工具
const mcpTools = {
  search_articles: {
    description: '搜索文章',
    schema: { ... },
    handler: async (args) => {
      return await articleService.search(args);
    }
  },
  
  get_user_stats: {
    description: '获取用户统计',
    schema: { ... },
    handler: async (args) => {
      return await userService.getStats(args);
    }
  }
};

// Claude 作为 Agent 调用这些工具
// 用户：分析一下我们社区的内容质量
// Claude Agent：
//   1. 调用 search_articles 获取最近文章
//   2. 调用 get_user_stats 分析作者活跃度
//   3. 综合分析并生成报告

// 使用缓存减少重复调用
const cache = new Map();

async function cachedToolCall(tool, args) {
  const cacheKey = `${tool}_${JSON.stringify(args)}`;
  
  if (cache.has(cacheKey)) {
    return cache.get(cacheKey);
  }
  
  const result = await tool.execute(args);
  cache.set(cacheKey, result);
  return result;
}

// 使用更便宜的模型做简单任务
function selectModel(taskComplexity) {
  if (taskComplexity === 'simple') {
    return 'gpt-3.5-turbo';  // 便宜
  } else {
    return 'gpt-4';           // 强大但贵
  }
}

class SafeAgent extends SimpleAgent {
  constructor(llm, tools, safetyConfig) {
    super(llm, tools);
    this.safetyConfig = safetyConfig;
  }
  
  async execute(goal) {
    // 检查目标是否包含危险关键词
    if (this.containsDangerousIntent(goal)) {
      throw new Error('检测到潜在危险操作，已拒绝执行');
    }
    
    return super.execute(goal);
  }
  
  async executeTool(tool, args) {
    // 工具白名单
    if (!this.safetyConfig.allowedTools.includes(tool.name)) {
      throw new Error(`工具 ${tool.name} 未授权`);
    }
    
    // 关键操作需人工确认
    if (this.safetyConfig.requireConfirmation.includes(tool.name)) {
      const confirmed = await this.askUserConfirmation(tool, args);
      if (!confirmed) {
        throw new Error('用户取消操作');
      }
    }
    
    // 参数校验
    this.validateArgs(tool, args);
    
    // 沙盒执行
    return await this.sandboxExecute(tool, args);
  }
  
  containsDangerousIntent(text) {
    const dangerousPatterns = [
      /删除.*文件/,
      /rm\s+-rf/,
      /DROP\s+TABLE/,
      /转账/,
      /支付/
    ];
    
    return dangerousPatterns.some(pattern => pattern.test(text));
  }
}

const safetyConfig = {
  allowedTools: [
    'search_web',
    'read_file',
    'write_file'
  ],
  requireConfirmation: [
    'delete_file',
    'send_email',
    'make_payment'
  ]
};

const safeAgent = new SafeAgent(llm, tools, safetyConfig);

// 带解释的 Agent 执行
class ExplainableAgent extends SimpleAgent {
  async execute(goal) {
    console.log(`\n🎯 收到任务: ${goal}`);
    console.log(`\n🤔 让我想想如何完成这个任务...\n`);
    
    // 先生成执行计划
    const plan = await this.createPlan(goal);
    
    console.log('📋 执行计划:');
    plan.steps.forEach((step, i) => {
      console.log(`  ${i + 1}. ${step.description}`);
      console.log(`     工具: ${step.tool}`);
      console.log(`     原因: ${step.reason}`);
    });
    
    const approval = await this.askApproval();
    if (!approval) {
      console.log('❌ 用户取消执行');
      return;
    }
    
    console.log('\n▶️  开始执行...\n');
    
    // 执行每一步并解释
    for (const [index, step] of plan.steps.entries()) {
      console.log(`\n[步骤 ${index + 1}/${plan.steps.length}] ${step.description}`);
      
      const result = await this.executeStep(step);
      
      console.log(`✓ 完成`);
      console.log(`  结果: ${this.summarizeResult(result)}`);
      console.log(`  下一步: ${this.explainNextStep(index, plan)}`);
    }
    
    console.log('\n✅ 所有步骤已完成！');
    return this.createFinalReport(plan);
  }
}

class LearningAgent extends SimpleAgent {
  async execute(goal) {
    const result = await super.execute(goal);
    
    // 从执行结果中学习
    await this.learn({
      task: goal,
      steps: this.memory,
      result: result,
      success: result.success,
      userFeedback: await this.getUserFeedback()
    });
    
    return result;
  }
  
  async learn(experience) {
    // 更新策略库
    if (experience.success && experience.userFeedback > 4) {
      // 这是一个好的解决方案，记住它
      this.strategyLibrary.add({
        pattern: this.extractPattern(experience.task),
        solution: experience.steps,
        successRate: 1.0
      });
    }
    
    // 避免重复错误
    if (!experience.success) {
      this.errorPatterns.add({
        situation: experience.task,
        failedApproach: experience.steps,
        lesson: await this.analyzeFailure(experience)
      });
    }
  }
}

// Human-in-the-Loop Agent
class CollaborativeAgent extends SimpleAgent {
  async execute(goal) {
    // 1. Agent 提出初步方案
    const proposal = await this.createProposal(goal);
    
    console.log('💡 我的建议:');
    console.log(proposal);
    
    // 2. 征求人类意见
    const feedback = await this.getHumanFeedback();
    
    // 3. 根据反馈调整
    const refinedPlan = await this.refinePlan(proposal, feedback);
    
    // 4. 执行，过程中关键点再次确认
    return await this.executeWithCheckpoints(refinedPlan);
  }
}