/**
 * Think 主动思考插件
 * 支持 LLM 自我唤醒、自动反思、持续思考
 */

const { Plugin } = require('../src/core/plugin-base')
const { logger } = require('../src/utils/logger')
const log = logger.child('Think')
const { z } = require('zod')

class ThinkPlugin extends Plugin {
  constructor(config = {}) {
    super()
    this.name = 'think'
    this.version = '1.0.0'
    this.description = '主动思考插件，支持 LLM 自我唤醒和持续思考'
    this.priority = 5  // 高优先级，早期加载

    this.config = {
      autoReflect: config.autoReflect === true,  // 默认关闭自动反思
      reflectDelay: config.reflectDelay || 2000,   // 反思延迟(ms)
      maxReflectDepth: config.maxReflectDepth || 3,  // 最大反思深度
      enableContinuous: config.enableContinuous || false  // 是否启用持续思考
    }
    this.tools = {}  // 存储注册的工具函数
    this._framework = null
    this._thoughts = []  // 思考记录
    this._reflectionChain = []  // 反思链
    this._continuousMode = false
    this._continuousTimer = null
    this._pendingReflection = null
  }

  install(framework) {
    this._framework = framework
    return this
  }

  start(framework) {
    // 注册思考工具
    this.tools.think_now =  {
      name: 'think_now',
      description: '立即触发 LLM 主动思考（用于反思、自我检视、生成想法）',
      inputSchema: z.object({
        topic: z.string().optional().describe('思考主题，不提供则让 LLM 自己决定思考什么'),
        mode: z.enum(['reflect', 'brainstorm', 'analyze', 'plan']).optional().describe('思考模式'),
        depth: z.number().optional().describe('思考深度 1-5')
      }),
      execute: async (args) => {
        return await this._triggerThinking(args)
      }
    }

    this.tools.think_continue = {
      name: 'think_continue',
      description: '让 LLM 持续思考模式（后台自动思考，定期输出结果）',
      inputSchema: z.object({
        interval: z.number().optional().describe('思考间隔毫秒，默认 30000 (30秒)'),
        topic: z.string().optional().describe('思考主题')
      }),
      execute: async (args) => {
        return await this._startContinuousThinking(args)
      }
    }

    this.tools.think_stop = {
      name: 'think_stop',
      description: '停止持续思考模式',
      inputSchema: z.object({}),
      execute: async () => {
        return this._stopContinuousThinking()
      }
    }

    this.tools.think_get_thoughts = {
      name: 'think_get_thoughts',
      description: '获取思考历史记录',
      inputSchema: z.object({
        limit: z.number().optional().describe('返回条数，默认 10')
      }),
      execute: async (args) => {
        const limit = args.limit || 10
        return {
          success: true,
          thoughts: this._thoughts.slice(-limit).reverse(),
          total: this._thoughts.length
        }
      }
    }

    return this
  }

  /**
   * 触发主动思考
   */
  async _triggerThinking(args) {
    const mode = args.mode || 'reflect'
    const depth = Math.min(args.depth || 2, 5)
    const topic = args.topic || '刚才的对话还有什么可以改进或补充的地方？'

    try {
      const agent = this._getActiveAgent()
      if (!agent) {
        return { success: false, error: 'No active agent found' }
      }

      // 检查 agent 是否有 AI 配置
      if (!agent.apiKey && !this._framework.pluginManager.get('ai')) {
        return {
          success: false,
          error: 'AI 未配置。请在 .agent/ai.json 或环境变量中配置 AI API Key。'
        }
      }

      const reflectPrompt = this._buildReflectPrompt(mode, depth, topic)
      const result = await agent.pushMessage(reflectPrompt)

      const thought = {
        id: Date.now(),
        mode,
        depth,
        topic,
        prompt: reflectPrompt,
        result: typeof result === 'string' ? result : JSON.stringify(result),
        timestamp: new Date()
      }

      this._thoughts.push(thought)
      if (this._thoughts.length > 100) {
        this._thoughts = this._thoughts.slice(-100)
      }

      // 触发思考完成事件
      if (this._framework) {
        this._framework.emit('think:thought_completed', thought)
      }

      return {
        success: true,
        thought,
        message: `【主动思考完成】\n模式: ${mode}\n主题: ${topic}\n\n${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}`
      }
    } catch (err) {
      return { success: false, error: err.message }
    }
  }

  /**
   * 构建反思提示
   */
  _buildReflectPrompt(mode, depth, topic) {
    const depthDesc = {
      1: '快速检视',
      2: '简单反思',
      3: '深入思考',
      4: '批判性分析',
      5: '全面审视'
    }

    const modePrompts = {
      reflect: `你刚刚完成了一次对话。请${depthDesc[depth]}：

1. 检查回答是否完整、准确
2. 是否有遗漏的重要信息
3. 是否有更好的表达方式
4. 是否需要补充示例或细节

${topic ? `额外关注: ${topic}` : ''}

请直接输出你的反思结果，不需要重复之前的对话内容。`,

      brainstorm: `请进行头脑风暴，针对以下主题产生更多想法：

${topic || '刚才讨论的内容'}

产生至少 3-5 个新的观点或方向，不必拘泥于之前讨论的内容。`,

      analyze: `请对以下主题进行深度分析：

${topic || '刚才讨论的内容'}

分析要点：
- 根本原因是什么？
- 有哪些支持/反对的证据？
- 可能的发展方向？`,

      plan: `基于目前的讨论，请制定下一步计划：

${topic || '接下来的行动'}

计划要具体、可执行，包含时间线和预期结果。`
    }

    return modePrompts[mode] || modePrompts.reflect
  }

  /**
   * 自动反思（响应完成后）
   */
  async _autoReflect(data) {
    if (!this._framework) return

    try {
      // 检查是否需要反思（避免短时间重复反思）
      const lastThought = this._thoughts[this._thoughts.length - 1]
      if (lastThought && Date.now() - lastThought.timestamp.getTime() < 10000) {
        return  // 10秒内不重复反思
      }

      const agent = this._getActiveAgent()
      if (!agent) return

      // 构建轻量级反思
      const reflectPrompt = `作为助手，请快速检视刚才的回答是否：
1. 完整回答了用户的问题
2. 表达清晰易懂
3. 有没有遗漏关键信息

如果发现不足，请直接补充。如果没问题，请简短回复"检查完毕，无需补充"。`

      // 静默思考，不打断用户
      const result = await agent.pushMessage(reflectPrompt)

      const thought = {
        id: Date.now(),
        mode: 'auto-reflect',
        topic: '自动检视',
        result: typeof result === 'string' ? result : '反思完成',
        timestamp: new Date(),
        auto: true
      }

      this._thoughts.push(thought)

      // 如果反思有重要补充，触发事件通知
      if (typeof result === 'string' && result.includes('补充') && !result.includes('无需补充')) {
        this._framework.emit('think:reflection_needs_attention', {
          thought,
          originalData: data
        })
      }
    } catch (err) {
      log.error(' Auto-reflect error:', err.message)
    }
  }

  /**
   * 启动持续思考模式
   */
  async _startContinuousThinking(args) {
    if (this._continuousMode) {
      return { success: false, error: 'Continuous thinking already running' }
    }

    const interval = args.interval || 30000
    const topic = args.topic || '基于最近的对话，还有什么值得深入思考的方向？'

    this._continuousMode = true
    this._continuousTopic = topic

    const runThink = async () => {
      if (!this._continuousMode) return

      try {
        await this._triggerThinking({
          topic: this._continuousTopic,
          mode: 'reflect',
          depth: 2
        })

        // 触发下一轮
        if (this._continuousMode) {
          this._continuousTimer = setTimeout(runThink, interval)
        }
      } catch (err) {
        log.error(' Continuous think error:', err.message)
      }
    }

    // 立即执行一次
    await runThink()

    return {
      success: true,
      message: `【持续思考已启动】\n间隔: ${interval}ms\n主题: ${topic}\n\nLLM 将定期自动思考并在有新想法时通知你。`
    }
  }

  /**
   * 停止持续思考模式
   */
  _stopContinuousThinking() {
    this._continuousMode = false
    if (this._continuousTimer) {
      clearTimeout(this._continuousTimer)
      this._continuousTimer = null
    }
    return {
      success: true,
      message: '持续思考已停止'
    }
  }

  /**
   * 获取当前活跃的 Agent
   */
  _getActiveAgent() {
    // 优先使用主 Agent
    if (this._framework._mainAgent) {
      return this._framework._mainAgent
    }

    // 否则找一个空闲的 Agent
    if (this._framework._agents && this._framework._agents.length > 0) {
      for (let i = this._framework._agents.length - 1; i >= 0; i--) {
        const agent = this._framework._agents[i]
        if (agent.getStatus() === 'idle') {
          return agent
        }
      }
    }
    return null
  }

  /**
   * 获取待处理的反思通知
   */
  getPendingThoughts() {
    return this._thoughts.slice(-10).reverse()
  }

  reload(framework) {
    this._framework = framework
  }

  uninstall(framework) {
    this._stopContinuousThinking()
    this._thoughts = []
    this._reflectionChain = []
    this._framework = null
  }
}

module.exports = ThinkPlugin
