//! 发送与队列管理 — sendMessage/regenerate/editMessage + 队列(drain/cancel/clear) + stopChat
//!
//! 审批链(approveToolCall/batchApprove)已拆分到 useAiApproval.ts(fe-arch P0-1)。
//!
//! L2 发送韧性:三级降级
//!   L0 normal:后端 idle → 直接发送
//!   L1 queued: 后端 busy → 入队等待(≤30s 正常排队)
//!   L2 force:  排队>30s → 弹 confirm → 用户确认后调 ai_chat_force_send 复位残留并强制发出
//!
//! 耦合:
//! - sendMessage 调 useAiEvents.startListener(useAiEvents 导出但不在解构集中暴露给组件,
//!   故 startListener 同时经 useAiEvents 导出,sendMessage 直接 import 调用)
//! - sendMessage 调 useAiStream.resetStreamWatchdog
//! - drainQueue 由 handleEvent(AiCompleted) 经 ai-drain-queue 事件总线触发(非直接调用,
//!   打破 events↔send 循环依赖);本模块模块级监听该事件

import { listen } from '@tauri-apps/api/event'
import { invoke } from '@tauri-apps/api/core'
import { ref } from 'vue'
import { aiApi } from '@/api'
import { state } from '@/stores/ai'
import type { ContentPart, AiMessage, MentionSpan, MessageId } from '@/api/types'
import { t } from '@/i18n/i18n-helpers'
import { resetStreamWatchdog, clearStreamWatchdog, clearResumeAttempts } from './useAiStream'
import { setStreaming } from './streamingGuard'
import { startListener } from './useAiEvents'
import { nextMsgId, startApprovalTimer, clearApprovalTimer, clearAllApprovalTimers, resolveAiLang, convStates, setConvCurrentText, setConvStreaming, flushCurrentText } from './aiShared'

/// 待发送队列上限（超过抛错提示用户）
const QUEUE_LIMIT = 10

/// 排队超时阈值(ms) — 超过后弹 confirm 让用户选择"强制发送"或继续等
const QUEUE_TIMEOUT_MS = 30_000

/**
 * 用户指定模型 override(主对话专用,模块级单例)。
 *
 * null=自动模式(路由器选);非空字符串=用户从下拉指定的 model_id。
 * 仅主对话(agentic)生效:doSend/sendMessage/regenerate/editMessage 透传给后端,
 * 标题/扫描/灵感等内部调用不读此字段。
 *
 * 后端兜底(agentic.rs):override 非空且在该 provider model_configs 池中才用,
 * 否则落回路由结果——绝不让 override 导致无模型。
 *
 * 模块级 ref(非组件级):AiChat 顶部下拉读写,发送链路读此 ref 透传,单实例不需 props/inject。
 * 切换会话后端会清自身 session.model_override;前端保留用户手选(每会话默认权重最高
 * 由 TopBar 兜底:仅当 override 空/对目标模型池无效时才重置),避免切会话往返丢失手选模型。
 */
const modelOverride = ref<string | null>(null)

// 审批计时器(startApprovalTimer/clearApprovalTimer/clearAllApprovalTimers)已下沉到 aiShared.ts
// 打破 useAiEvents ↔ useAiSend 循环依赖。本模块 re-export 供组件使用。

/**
 * 入队时记录时间戳,供 UI 展示排队时长和触发超时提示。
 * queue item 扩展: 原 { text, skill? } → { text, skill?, enqueuedAt, parts? }
 * 兼容 drainQueue/cancelQueued/clearQueue 等已有消费方(enqueuedAt/parts 仅读不写)。
 */

// ── 内核发送:推送气泡+调 IPC,被 normal/force 两条路径共用 ──

/**
 * 内核发送:推送气泡 + 调 IPC,被 normal/force 两条路径共用。
 *
 * @param convId 目标会话 id(显式传入优先,缺省当前活跃会话)。后台会话续发(drainQueue)场景
 *        目标会话 ≠ 当前活跃视图,此时不 push 本地气泡、不碰当前视图流式态,避免污染当前视图。
 */
async function doSend(text: string, skill?: string, force = false, parts?: ContentPart[], spans?: MentionSpan[], convId?: string | null) {
  // 目标会话:显式传入优先,缺省当前活跃会话。
  const targetConvId = convId ?? state.activeConversationId
  // state.messages 是当前活跃会话的全局视图;后台会话续发不 push 本地气泡,
  // 切回目标会话时由切换加载从 DB/事件恢复完整历史,避免把 A 的消息污染 B 的视图。
  const isViewTarget = !targetConvId || targetConvId === state.activeConversationId
  // 防御:先 flush 残留 currentText(正常情况已是空,flushCurrentText 直接 return;
  // 异常时序下可防止上一轮文本被清空误伤)。仅当前视图会话发送才 flush,后台续发不碰当前视图流式文本。
  if (isViewTarget) flushCurrentText()

  const userMsgId = `user-${nextMsgId()}`
  const aiMsgId = `ai-${nextMsgId()}`
  if (isViewTarget) {
    state.messages.push({
      id: userMsgId as MessageId,
      role: 'user',
      content: text.trim(),
      // 仅在非空时挂 parts(纯文本消息保持 undefined,渲染走原 content 路径零回归)
      parts: parts && parts.length > 0 ? parts : undefined,
      // Input Augmentation: 仅在非空时挂 mentionSpans(供消息列表 chip 渲染;空则 undefined 零回归)
      mentionSpans: spans && spans.length > 0 ? spans : undefined,
      timestamp: Date.now(),
    })

    state.messages.push({
      id: aiMsgId as MessageId,
      role: 'assistant',
      content: '',
      timestamp: Date.now(),
    })
    setStreaming(true, { convId: targetConvId, reason: 'doSend' })
    state.currentText = ''
    // 启动流式看门狗(per-conv,无数据超时兜底)
    resetStreamWatchdog(targetConvId || undefined)
  } else {
    // 后台会话续发:直接写其 per-conv 流式态(setStreaming 写当前活跃视图,后台场景会写错会话);
    // 不 arm 看门狗(目标会话流式态暂由切换加载时按会话状态重算,后台不干扰当前视图)。
    setConvStreaming(targetConvId, true)
    setConvCurrentText(targetConvId, '')
  }

  await startListener()
  const lang = resolveAiLang()
  try {
    // force=true 走 force_send IPC(复位残留 generating),否则走正常 send
    const override = modelOverride.value
    if (force) {
      // 透传 parts(图片) + mentionSpans + 目标会话 id
      await aiApi.forceSend(text.trim(), lang, skill, override, parts, targetConvId, spans)
    } else {
      await aiApi.sendMessage(text.trim(), lang, skill, override, parts, targetConvId, spans)
    }
  } catch (e) {
    // IPC 失败(spawn 前/provider 配置错等):回滚目标会话 streaming 防光标卡死 + 移除本地气泡占位;
    // 重新抛出由调用方回填输入框,用户可重试。彻底清理会话状态,避免按钮永久红色。
    const failConvId = targetConvId
    if (isViewTarget) {
      setStreaming(false, { convId: failConvId, reason: 'doSend-ipc-fail' })
      state.messages = state.messages.filter(m => m.id !== aiMsgId && m.id !== userMsgId)
    } else {
      setConvStreaming(failConvId, false)
    }
    clearStreamWatchdog(failConvId || undefined)
    if (failConvId) convStates.delete(failConvId)
    throw e
  }
}

/**
 * 重新生成最后一条 AI 回复。
 *
 * 与 doSend 的区别:
 * - 不 push 新 user 消息(触发它的 user 消息已在历史末尾)
 * - 仅 push 一个空 AI 气泡占位 + 置 streaming,后端弹出旧 AI 回复后重跑 loop
 * - 失败回滚只移除占位气泡(不移除 user 消息)
 *
 * 后端 ai_regenerate 占用 generating 防并发双发,此处不再额外入队/预检。
 */
async function regenerate() {
  // 末尾须有 AI 回复可重生成(后端也会校验,前端先挡避免空跑)
  const msgs = state.messages
  const last = msgs[msgs.length - 1]
  if (!last || last.role !== 'assistant') {
    throw new Error(t('aiChat.regenerateUnavailable'))
  }

  // 移除末尾旧 AI 气泡(后端也弹 history;前端先弹避免占位前残留旧文),push 空气泡占位
  state.messages.pop()
  const aiMsgId = `ai-${nextMsgId()}`
  state.messages.push({
    id: aiMsgId as MessageId,
    role: 'assistant',
    content: '',
    timestamp: Date.now(),
  })

  setStreaming(true, { convId: state.activeConversationId, reason: 'regenerate' })
  state.currentText = ''
  // 只清当前会话的排队消息,不误伤其他会话
  const regenConvId = state.activeConversationId
  state.queue = state.queue.filter(q => q.conversationId !== regenConvId)
  // 会话态走 per-conv 键(与 doSend 一致),不再落 legacy 单 timer fallback
  resetStreamWatchdog(regenConvId || undefined)

  await startListener()
  const lang = resolveAiLang()
  const convId = state.activeConversationId
  if (!convId) {
    // 无活跃对话:回滚占位,报错
    setStreaming(false, { reason: 'regenerate-no-conv' })
    clearStreamWatchdog(regenConvId || undefined)
    state.messages = state.messages.filter(m => m.id !== aiMsgId)
    throw new Error(t('aiChat.regenerateUnavailable'))
  }
  try {
    await aiApi.regenerate(convId, lang, modelOverride.value)
  } catch (e) {
    // IPC 失败:回滚 streaming + 移除占位气泡(旧回复后端已弹但前端先弹了,保持弹后态)
    setStreaming(false, { convId, reason: 'regenerate-ipc-fail' })
    clearStreamWatchdog(convId || undefined)
    state.messages = state.messages.filter(m => m.id !== aiMsgId)
    throw e
  }
}

/**
 * 编辑最后一条 user 消息并重新生成。
 *
 * 与 regenerate 的区别:
 * - regenerate:末条须是 assistant,pop 旧 AI 回复后重跑
 * - editMessage:末条须是 user(中间编辑被后端拒绝),就地改其 content,截断其后所有消息,
 *   push 空气泡占位后重跑。被截断消息后端标 truncated(软删保留 DB),前端视图层同步移除。
 *
 * 后端 ai_chat_edit 占用 generating 防并发双发,此处不再额外入队/预检。
 *
 * @param newMessage 编辑后的新内容(替换末条 user 消息 content)
 */
async function editMessage(newMessage: string) {
  if (!newMessage.trim()) return

  // 末条须是 user(中间编辑语义复杂,拒绝);后端也会校验,前端先挡避免空跑
  const msgs = state.messages
  const last = msgs[msgs.length - 1]
  if (!last || last.role !== 'user') {
    throw new Error(t('aiChat.editNotLastUser'))
  }

  // 截断末条 user 之后的消息(此时 last 即末条 user,其后应已有 assistant 回复或为空)
  // 找到末条 user 的下标,移除其后所有消息
  let lastUserIdx = -1
  for (let i = msgs.length - 1; i >= 0; i--) {
    if (msgs[i].role === 'user') { lastUserIdx = i; break }
  }
  if (lastUserIdx < 0) {
    throw new Error(t('aiChat.editNotLastUser'))
  }
  // 截断其后(保留末条 user 本身,改其 content)
  state.messages.splice(lastUserIdx + 1)
  msgs[lastUserIdx].content = newMessage.trim()

  // push 空气泡占位(新 AI 回复将流入)
  const aiMsgId = `ai-${nextMsgId()}`
  state.messages.push({
    id: aiMsgId as MessageId,
    role: 'assistant',
    content: '',
    timestamp: Date.now(),
  })

  setStreaming(true, { convId: state.activeConversationId, reason: 'editMessage' })
  state.currentText = ''
  // 只清当前会话的排队消息,不误伤其他会话
  const editConvId = state.activeConversationId
  state.queue = state.queue.filter(q => q.conversationId !== editConvId)
  // 会话态走 per-conv 键(与 doSend 一致),不再落 legacy 单 timer fallback
  resetStreamWatchdog(editConvId || undefined)

  await startListener()
  const lang = resolveAiLang()
  const convId = state.activeConversationId
  if (!convId) {
    setStreaming(false, { reason: 'editMessage-no-conv' })
    clearStreamWatchdog(editConvId || undefined)
    state.messages = state.messages.filter(m => m.id !== aiMsgId)
    throw new Error(t('aiChat.editNotLastUser'))
  }
  try {
    await aiApi.editMessage(convId, newMessage.trim(), lang, modelOverride.value)
  } catch (e) {
    // IPC 失败:回滚 streaming + 移除占位气泡(被截断的旧回复后端已标 truncated,前端已移除)
    setStreaming(false, { convId, reason: 'editMessage-ipc-fail' })
    clearStreamWatchdog(convId || undefined)
    state.messages = state.messages.filter(m => m.id !== aiMsgId)
    throw e
  }
}

/**
 * 取出队首并发送（AiCompleted 触发，此时 streaming 已 false）。
 *
 * 原 fire-and-forget 吞没了 doSend IPC 失败 throw,既无 AiCompleted 触发下次 drain(队列永久
 * 卡死),也无任何用户反馈。现显式 catch:复位 streaming + 推错误气泡(后台会话不推,避免污染
 * 当前视图)+ 回填失败消息到该会话队首并停 drain(不静默丢用户输入,保留剩余队列供手动重试/
 * 编辑/取消)。成功路径不受影响——doSend 成功后端会再 emit AiCompleted 续 drain 链路。
 *
 * 并发互斥 — 每个会话维护 _draining 标志,防止 AiCompleted 并发触发两次 drainQueue
 * 导致 splice 两条消息同时发送,顺序错乱。已在 drain 中则跳过,等待下一次 AiCompleted 续发。
 */
let _drainingConvs = new Set<string>()
export function drainQueue(convId?: string | null) {
  if (state.queue.length === 0) return
  // 找队首属于目标会话的消息;若穿越(非目标会话的项堵在队首)则跳过整条队列
  const targetId = convId ?? state.activeConversationId
  if (!targetId) return
  // 并发互斥:该会话已在 drain 中则跳过,由下一轮 AiCompleted 续发
  if (_drainingConvs.has(targetId)) return
  const idx = state.queue.findIndex(q => q.conversationId === targetId)
  if (idx === -1) return
  _drainingConvs.add(targetId)
  const next = state.queue.splice(idx, 1)[0]!
  void (async () => {
    try {
      // 用目标会话 id 发送(而非当前活跃会话),避免切走后把 A 的队首消息误发到 B;spans 一并透传
      await sendMessage(next.text, next.skill, false, next.parts, next.spans, targetId)
    } catch (e) {
      // 失败时彻底收尾:带目标会话 id 精准清理 per-conv 看门狗 + 会话状态
      setConvStreaming(targetId, false)
      clearStreamWatchdog(targetId || undefined)
      if (targetId) convStates.delete(targetId)
      const errMsg = e instanceof Error ? e.message : String(e)
      // 回填失败消息到该会话队首,保留剩余队列(不静默丢用户输入)
      const reIdx = state.queue.findIndex(q => q.conversationId === targetId)
      state.queue.splice(reIdx === -1 ? state.queue.length : reIdx, 0, next)
      // 仅目标会话为当前视图才推错误气泡(后台会话续发失败不污染当前视图;错误消息留在队列
      // 供切回后编辑/重试/取消)
      if (targetId === state.activeConversationId) {
        state.messages.push({
          id: `err-${nextMsgId()}`,
          role: 'assistant',
          content: t('ai.queuedSendFailed', { error: errMsg }),
          isError: true,
          timestamp: Date.now(),
        } as AiMessage)
      }
      console.error('[AI] drainQueue 续发失败:', e)
    } finally {
      _drainingConvs.delete(targetId)
    }
  })()
}

/**
 * 发送消息 — 三级降级(L0 直接发 / L1 入队 / L2 强制):
 *
 * L0 normal:  后端 idle → 直接 doSend()
 * L1 queued:  后端 busy → 入队等 AiCompleted 续发
 * L2 force:   排队>30s → 返回特殊标记,由调用方(handleSend)弹 confirm;
 *             用户确认后重新进 sendMessage(forceMode=true)走 forceSend IPC
 *
 * forceMode=true 时跳过入队,直接走 ai_chat_force_send。
 *
 * @param convId 目标会话 id(显式传入优先,缺省当前活跃会话)。后台会话续发(drainQueue)必须
 *        显式传目标会话,否则切走后会用当前活跃会话发错消息。
 *
 * 注:入队条件仅用 backendGenerating(IPC 查后端真实态),不再检查 state.streaming。
 * streaming 是渲染态(文本是否在屏幕上输出),不能作为「后端能否接收消息」的代理。
 */
async function sendMessage(text: string, skill?: string, forceMode = false, parts?: ContentPart[], spans?: MentionSpan[], convId?: string | null) {
  if (!text.trim() && !(parts && parts.length)) return
  // 目标会话:显式传入优先(后台会话续发场景),缺省当前活跃会话
  const targetConvId = convId ?? state.activeConversationId

  // ── L2 强制模式:跳过所有预检,直接 force_send ──
  if (forceMode) {
    await doSend(text, skill, true, parts, spans, targetConvId)
    return
  }

  // 发送前 IPC 查后端真实 generating(精确查目标会话,不读全局单值)。
  let backendGenerating = false
  try {
    backendGenerating = await invoke<boolean>('ai_is_generating', { conversationId: targetConvId || null })
  } catch {
    backendGenerating = false
  }

  // ── L1:后端 busy → 入队(消息已在本地显示,待后端空闲后自动发送)──
  // 仅用 backendGenerating,不用 state.streaming。streaming 是渲染态,不是后端忙的代理。
  if (backendGenerating) {
    if (state.queue.length >= QUEUE_LIMIT) {
      throw new Error(t('ai.queueFull', { limit: QUEUE_LIMIT }))
    }
    state.queue.push({
      text: text.trim(),
      skill: skill || undefined,
      enqueuedAt: Date.now(),
      parts: parts && parts.length > 0 ? parts : undefined,
      spans: spans && spans.length > 0 ? spans : undefined,
      conversationId: targetConvId,
    })
    return
  }

  // ── L0:normal 直接发送 ──
  await doSend(text, skill, false, parts, spans, targetConvId)
}

/** 排队是否已超时(任一条超即算,因队首阻塞导致后续全堵;未传 convId 时仅看当前活跃会话队列) */
export function isQueueTimedOut(convId?: string | null): boolean {
  const targetConv = convId ?? state.activeConversationId
  const q = targetConv ? state.queue.filter(x => x.conversationId === targetConv) : state.queue
  const first = q[0]
  return first !== undefined && (Date.now() - first.enqueuedAt > QUEUE_TIMEOUT_MS)
}

/**
 * 超时时弹 confirm,用户确认后以 force_mode 重发目标会话队首消息;取消则保持排队。
 *
 * force_send 失败时,队首已移除,此处回填到该会话队首(原全局 unshift 在跨会话队列下会错位),
 * 并复位目标会话 streaming / 清看门狗,让 UI 脱卡死态。不自动重试 force(避免循环),交用户决定。
 */
export async function tryForceSend(confirmFn: (msg: string) => Promise<boolean>, convId?: string | null): Promise<boolean> {
  const targetConv = convId ?? state.activeConversationId
  const idx = targetConv ? state.queue.findIndex(q => q.conversationId === targetConv) : 0
  const first = idx === -1 ? undefined : state.queue[idx]
  if (!first) return false
  const confirmed = await confirmFn(t('ai.forceSendConfirm'))
  if (!confirmed) return false
  // 从队列移除该会话队首,以 force_mode 发送
  state.queue.splice(idx, 1)
  // 清看门狗:doSend 内 force_send 路径会重设 streaming=true 并重启看门狗,
  // 此处无需前置 false(前置 false 会触发消息列表 watch 清流式块再重建,产生瞬态抖动)
  clearStreamWatchdog(targetConv || undefined)
  try {
    await sendMessage(first.text, first.skill, true, first.parts, first.spans, first.conversationId)
    return true
  } catch (e) {
    // force_send 也失败:回填该会话队首保消息不丢,复位 streaming 让 UI 可继续操作
    const reIdx = targetConv ? state.queue.findIndex(q => q.conversationId === targetConv) : 0
    state.queue.splice(reIdx === -1 ? state.queue.length : reIdx, 0, {
      text: first.text,
      skill: first.skill,
      enqueuedAt: first.enqueuedAt,
      parts: first.parts,
      spans: first.spans,
      conversationId: first.conversationId,
    })
    setStreaming(false, { convId: targetConv ?? state.activeConversationId, reason: 'tryForceSend-fail' })
    clearStreamWatchdog(targetConv || undefined)
    console.error('[AI] tryForceSend force_send 失败,消息已回填队首:', e)
    return false
  }
}

/** 批量审批已拆分到 useAiApproval.ts(fe-arch P0-1) */

/**
 * 把「当前活跃会话视图内的队列下标」映射到全局队列真实下标。
 *
 * 队列区在 AiChat.vue 按 activeConversationId 过滤渲染(activeQueue),UI 上的编辑/删除/立即发送
 * 传的是过滤视图内的 idx。此处按当前活跃会话在全局队列中定位真实下标;越界(项已被并发 drain
 * 移除等)返 -1,调用方据此 no-op。
 */
function activeQueueRealIndex(idx: number): number {
  const targetConv = state.activeConversationId
  if (!targetConv) return -1
  let seen = -1
  for (let i = 0; i < state.queue.length; i++) {
    if (state.queue[i].conversationId === targetConv) {
      seen++
      if (seen === idx) return i
    }
  }
  return -1
}

/** 取消队列中指定位置的消息(仅当前活跃会话视图内的队列项) */
function cancelQueued(index: number) {
  const realIdx = activeQueueRealIndex(index)
  if (realIdx === -1) return
  state.queue.splice(realIdx, 1)
}

/** 清空待发送队列(未传 convId 时仅清当前活跃会话;空 active 则全清兜底) */
function clearQueue(convId?: string | null) {
  const targetConv = convId ?? state.activeConversationId
  if (targetConv) {
    state.queue = state.queue.filter(q => q.conversationId !== targetConv)
  } else {
    state.queue = []
  }
}

/**
 * 编辑队列项的 text(决策只编 text)。
 *
 * 设计:
 * - 只改 text,skill 编辑态不暴露(skill 来自发送时技能联想,编辑态改 skill 复杂化交互无收益)。
 * - 边界:index 越界 / newText 空白 → 直接忽略(no-op),不抛错(UI 不会触发,防御)。
 */
function editQueued(index: number, newText: string) {
  const realIdx = activeQueueRealIndex(index)
  if (realIdx === -1) return
  const trimmed = newText.trim()
  if (!trimmed) return
  state.queue[realIdx].text = trimmed
}

/**
 * 队列项立即发送(插队=打断当前+发本条,复用停止链路)。
 *
 * 顺序关键:
 * 1. 先 splice 出该项——必须在 stopChat 之前,否则 stopChat→AiCompleted→drainQueue 续发时
 *    该项还在队列致重复发。
 * 2. 调 stopChat() 打断当前生成(停止后已不清队列,故 splice 步骤前置必要)。
 * 3. 直接 sendMessage(..., forceMode=true) 立即发这条(不等 drainQueue 轮到)。
 *    当前未完成回复已由停止截断保留,无需额外处理。
 */
async function sendQueuedNow(index: number) {
  const realIdx = activeQueueRealIndex(index)
  if (realIdx === -1) return
  const spliced = state.queue.splice(realIdx, 1)[0]
  await stopChat()
  // forceMode=true 跳过 L1 预检(后端 generating 判定)直走 force_send:stopChat 仅发出停止信号
  // (置 stop_flag),不等后端 loop 跑到检测点复位 generating,紧接的普通发送会命中 L1 的
  // backendGenerating(后端真值仍 true)→ spliced 被入队而非立即发,与"立即发送"语义不符。
  // force_send 原子复位 generating=false 再发,无竞态窗口;stop_flag 让旧 loop 在下个检测点退出。
  // 显式传 spliced 所属会话 id(当前活跃视图内操作,即当前会话)。
  await sendMessage(spliced.text, spliced.skill, true, spliced.parts, spliced.spans, spliced.conversationId)
}

/** 停止当前生成：本地先复位 streaming，再发停止信号。
 *  不依赖后端 AiCompleted 收尾——审批态看门狗已 clear(useAiEvents)，若 AiCompleted 竞态丢失则 streaming 永久 true 卡死，故本地兜底。
 *
 *  stop IPC 失败时的兜底。本地已先置 streaming=false，但若 stop 信号未送达后端，
 *  后端会继续生成并发回 delta/Completed 事件，与用户已感知的「已停止」语义冲突；更坏情况是
 *  后端 hang 既不收尾也不发事件(stop_flag 未置位、无 watchdog 兜底则无恢复路径)。
 *  故 stop 失败时不 clearStreamWatchdog，反而重启看门狗：后端若继续生成，活跃 delta 会不断重置它
 *  不误触发；后端若真 hang，130s 后 onStreamTimeout 兜底复位 streaming+清队列+推错误气泡。
 *  同时推一条 stopLoopFailed 错误消息让用户知晓停止未生效(可再点或等待收尾)。
 */
async function stopChat() {
  // 本地复位前先回填已流出文本:streaming 翻 false 后流式分块即清,迟到的 AiCompleted
  // 又会因 flushCurrentText 的非流式守卫跳过回填,不在此处 flush 则部分回复随停止丢失。
  flushCurrentText()
  setStreaming(false, { convId: state.activeConversationId, reason: 'stopChat' }) // 本地先复位，不依赖后端 AiCompleted（审批态看门狗已 clear，竞态丢失则卡死）
  // 停止属正常收尾:按目标会话清 per-conv 看门狗与自动续跑计数(计数只放收尾路径清,
  // 不在发消息时清,否则会掩盖单轮内的真实重试次数)
  clearStreamWatchdog(state.activeConversationId || undefined)
  clearResumeAttempts(state.activeConversationId || undefined)
  // 决策 a(逐条续发):不再清队列,保留供 AiCompleted 链式触发 drainQueue 续发。
  // 后端 agentic/mod.rs emit AiCompleted 注释明确「保证前端收事件时后端已可接下一条,队列续发不被拒」;
  // 当前未完成回复已入库(agentic/mod.rs save_conversation)保留为截断回复。
  try {
    // F-260616-09 B 批4(决策 e):传 activeConversationId,停止仅作用于当前 conv。
    await aiApi.stopChat(state.activeConversationId)
  } catch (e) {
    // stop 信号未送达后端:重启看门狗(后端继续生成时活跃事件会重置它,真 hang 则 130s 后兜底收尾),
    // 避免后端仍在跑却无任何恢复路径(原 clearStreamWatchdog 已把兜底关掉)。
    resetStreamWatchdog(state.activeConversationId || undefined)
    const errMsg = e instanceof Error ? e.message : String(e)
    state.messages.push({
      id: `stop-err-${nextMsgId()}`,
      role: 'assistant',
      content: t('aiChat.stopLoopFailed', { msg: errMsg }),
      isError: true,
      timestamp: Date.now(),
    } as AiMessage)
    console.error('[AI] stopChat IPC 失败,已重启看门狗兜底:', e)
  }
}

export function useAiSend() {
  return {
    sendMessage,
    regenerate,
    editMessage,
    drainQueue,
    cancelQueued,
    clearQueue,
    editQueued, //
    sendQueuedNow, //
    stopChat,
    isQueueTimedOut,
    tryForceSend,
    // F-01 阶段6: 模型 override(主对话专用),顶部下拉读写
    modelOverride,
    // 审批计时器已下沉到 aiShared.ts,此处 re-export 供组件使用
    startApprovalTimer,
    clearApprovalTimer,
    clearAllApprovalTimers,
  }
}

// 模块级监听 ai-drain-queue 事件(由 useAiEvents AiCompleted case 发射)
// 打破 useAiEvents ↔ useAiSend 循环依赖:events 不再直接 import 调用 drainQueue
let _drainUnlisten: (() => void) | null = null
export async function initDrainQueueListener(): Promise<void> {
  if (_drainUnlisten) return
  _drainUnlisten = await listen('ai-drain-queue', (event: any) => {
    drainQueue(event?.payload?.conversationId ?? null)
  })
}