// DeerFlow 智能体状态管理模块
import { defineStore } from "pinia";
import { ref } from "vue";
import {
  streamDeerFlowChat,
  getDeerFlowRAGResources,
  saveDeepSearch,
} from "@/api/deerflow";
import { cancelChat } from "@/api/chat";
import { useSchedulesStore } from "@/stores/schedules";
import { triggerNewbieTask } from "@/utils/newbieTask";

interface DeerFlowMessage {
  id: string;
  role: "user" | "assistant";
  content: string;
  agent?: string | null;
  currentAgent?: string;
  agentContents?: Record<string, AgentContent>;
  reasoningContent?: string;
  reasoningContentChunks?: string[];
  createdAt: string;
  updatedAt?: string;
  threadId?: string;
  status?: string;
  thoughtExpanded?: boolean;
  finishReason?: string | null;
  options?: any;
  isStreaming?: boolean;
  toolCalls?: any[];
  contentChunks?: string[];
  planData?: any;
  plannerFinished?: boolean; // 标记 planner 是否已完成
  feedback?: string; // 用户反馈: positive | negative
  feedbackTags?: string[]; // 用户反馈标签
  feedbackSubmitted?: boolean; // 是否已提交反馈
  deepSearchId?: number; // 关联的后端深度检索 ID
}

interface AgentContent {
  content: string;
  contentChunks: string[];
  reasoningContent: string;
  reasoningContentChunks: string[];
  isStreaming: boolean;
  status: string;
  updatedAt?: string;
  isUserEdited?: boolean; // 标记内容是否被用户编辑过
}

interface ProcessingStatus {
  isPlanGenerating: boolean; // 计划生成中
  isResearchInProgress: boolean; // 检索内容中
  isReportGenerating: boolean; // 报告生成中
  isResearchCompleted: boolean; // 研究完成，等待查看报告
}

export const useDeerFlowStore = defineStore("deerflow", () => {
  /**
   * 从可能包含“多个 JSON 对象/数组”的文本中，提取最后一个可解析的 JSON 对象。
   * 典型场景：planner 被用户编辑后，后端可能返回 "{}{...}" 或 "{}\n{...}" 等拼接内容。
   */
  function extractLastJsonObject(text: string): any | null {
    if (!text) return null;
    const trimmed = text.trim();
    if (!trimmed) return null;

    // 1) 先尝试直接 parse（支持标准 object / array）
    try {
      const parsed = JSON.parse(trimmed);
      if (Array.isArray(parsed)) {
        // 取最后一个“对象”元素（如果没有则取最后一个元素）
        for (let i = parsed.length - 1; i >= 0; i--) {
          if (parsed[i] && typeof parsed[i] === "object") return parsed[i];
        }
        return parsed.length ? parsed[parsed.length - 1] : null;
      }
      if (parsed && typeof parsed === "object") return parsed;
    } catch {
      // ignore
    }

    // 2) 尝试从文本中扫描出多个 {...} 片段，取最后一个可 parse 的对象
    const candidates: string[] = [];
    let depth = 0;
    let start = -1;
    let inString = false;
    let escape = false;

    for (let i = 0; i < trimmed.length; i++) {
      const ch = trimmed[i];
      if (inString) {
        if (escape) {
          escape = false;
        } else if (ch === "\\") {
          escape = true;
        } else if (ch === '"') {
          inString = false;
        }
        continue;
      }

      if (ch === '"') {
        inString = true;
        continue;
      }

      if (ch === "{") {
        if (depth === 0) start = i;
        depth++;
      } else if (ch === "}") {
        if (depth > 0) depth--;
        if (depth === 0 && start >= 0) {
          candidates.push(trimmed.slice(start, i + 1));
          start = -1;
        }
      }
    }

    for (let i = candidates.length - 1; i >= 0; i--) {
      try {
        const candidate = candidates[i];
        if (!candidate) continue;
        const obj = JSON.parse(candidate);
        if (obj && typeof obj === "object") return obj;
      } catch {
        // ignore
      }
    }

    return null;
  }

  // State
  const connected = ref(false);
  const connecting = ref(false);
  const connectionError = ref<string | null>(null);
  const currentThreadId = ref<string | null>(null);
  const messages = ref<DeerFlowMessage[]>([]);
  const streaming = ref(false);
  const streamingError = ref<string | null>(null);
  // 标记当前是否为历史回放模式（replay），回放时不向后端发 cancel
  const isReplayStreaming = ref(false);
  const config = ref<any>(null);
  const ragResources = ref<any[]>([]);
  const currentStream = ref<any>(null);
  const aiThinking = ref(false);
  const aiTyping = ref(false);
  const toolCalling = ref(false);
  const currentToolCalls = ref<any[]>([]);
  const interruptPending = ref(false);
  const interruptOptions = ref<any[]>([]);
  const processingStatus = ref<ProcessingStatus>({
    isPlanGenerating: false,
    isResearchInProgress: false,
    isReportGenerating: false,
    isResearchCompleted: false,
  });
  const schedulesStore = useSchedulesStore();
  // 按 threadId 缓存后端 status 的 interrupted，用于控制 UI 是否需要用户确认计划
  const threadInterruptedMap = ref<Record<string, boolean>>({});

  function setThreadInterrupted(threadId: string, interrupted: boolean) {
    if (!threadId) return;
    threadInterruptedMap.value[threadId] = interrupted;
  }

  function getThreadInterrupted(threadId: string): boolean | undefined {
    if (!threadId) return undefined;
    return threadInterruptedMap.value[threadId];
  }

  // 当前正在执行的深度检索任务 ID
  const currentRunningTaskId = ref<number | null>(null);

  // 从 Markdown 内容中提取第一个标题
  const extractTitleFromMarkdown = (content: string): string => {
    if (!content) return "";

    // 尝试提取 Markdown 一级标题 (# 标题)
    const h1Match = content.match(/^#\s+(.+)$/m);
    if (h1Match && h1Match[1]) {
      return h1Match[1].trim();
    }

    // 如果没有标题标记，尝试获取第一行非空文本（最多100个字符）
    const lines = content.split("\n").filter((line) => line.trim());
    if (lines.length > 0 && lines[0]) {
      const firstLine = lines[0].trim();
      return firstLine.length > 100
        ? firstLine.substring(0, 100) + "..."
        : firstLine;
    }

    return "";
  };

  // Actions
  async function initDeerFlow() {
    try {
      connecting.value = true;
      connectionError.value = null;

      connected.value = true;
    } catch (error: any) {
      console.error("DeerFlow 初始化失败:", error);
      connectionError.value = error.message || "连接失败";
      connected.value = false;
    } finally {
      connecting.value = false;
    }
  }

  async function fetchRAGResources(query: string = "") {
    try {
      const resources = await getDeerFlowRAGResources(query);
      ragResources.value = resources.resources || [];
      return resources;
    } catch (error) {
      console.error("获取 RAG 资源失败:", error);
      throw error;
    }
  }

  async function sendMessage({
    content,
    threadId = null,
    resources = [],
    options = {},
  }: {
    content: string;
    threadId?: string | null;
    resources?: any[];
    options?: any;
  }) {
    try {
      // 触发新手任务：深度检索（提问即算完成）
      triggerNewbieTask("deep_search_report");

      // 重置处理状态
      processingStatus.value = {
        isPlanGenerating: false,
        isResearchInProgress: false,
        isReportGenerating: false,
        isResearchCompleted: false,
      };

      // 设置线程ID - 优先使用传入的 threadId，其次使用已保存的 currentThreadId
      const threadIdValue = threadId || currentThreadId.value;

      if (!threadIdValue) {
        throw new Error("threadId 是必需的，请在调用 sendMessage 时传入");
      }

      // 保存 threadId 到 store
      if (!currentThreadId.value) {
        currentThreadId.value = threadIdValue;
      }

      // 添加用户消息
      const userMessage: DeerFlowMessage = {
        id: `msg_${Date.now()}`,
        role: "user",
        content: content.trim(),
        createdAt: new Date().toISOString(),
        threadId: threadIdValue,
      };
      messages.value.push(userMessage);

      // 添加 AI 响应占位符
      const aiMessage: DeerFlowMessage = {
        id: `msg_${Date.now() + 1}`,
        role: "assistant",
        agent: null,
        content: "",
        contentChunks: [],
        reasoningContent: "",
        reasoningContentChunks: [],
        createdAt: new Date().toISOString(),
        threadId: threadIdValue,
        status: "thinking",
        thoughtExpanded: true,
        finishReason: null,
        options: null,
        isStreaming: true,
        toolCalls: [],
        agentContents: {},
      };
      messages.value.push(aiMessage);

      // 准备消息历史
      const msgHistory = messages.value
        .filter((msg) => msg.role === "user" || msg.role === "assistant")
        .map((msg) => ({
          role: msg.role,
          content: msg.content,
        }));

      // 开始流式对话
      await startStreaming({
        messages: msgHistory,
        threadId: threadIdValue,
        resources,
        ...options,
      });
    } catch (error: any) {
      console.error("=== DeerFlow sendMessage 失败 ===", error);
      streamingError.value = error.message || "发送失败";
      const lastMessage = messages.value[messages.value.length - 1];
      if (lastMessage) {
        lastMessage.status = "error";
        lastMessage.content = "发送失败，请重试";
      }
    }
  }

  async function startStreaming(params: any) {
    // 关闭之前的流
    if (currentStream.value) {
      try {
        currentStream.value.close();
      } catch (e) {
        console.warn("关闭之前的流失败:", e);
      }
    }

    streaming.value = true;
    streamingError.value = null;
    aiThinking.value = true;

    // ⭐ 准备消息历史
    const msgHistory = params.messages || [];

    // 如果开启了知识库模式，且还没有系统指令，则注入系统指令引导 Planner
    if (
      params.literature_filters?.use_surveyx &&
      !msgHistory.some((m: any) => m.role === "system")
    ) {
      msgHistory.unshift({
        role: "system",
        content: `你现在处于“知识库检索模式”。请仅使用提供的知识库文件（file_ids）进行检索、分析和总结。在制定计划（Planner）时，严禁提及或使用 PubMed、ClinicalTrials.gov、Google Scholar 等任何外部数据源。你的所有操作都必须局限在本地知识库文件内，不要产生任何需要调用外部搜索接口的计划。`,
      });
    }

    // 如果没有传入消息历史，则根据 messages.value 准备
    if (msgHistory.length === 0) {
      msgHistory.push(
        ...messages.value
          .filter((msg) => msg.role === "user" || msg.role === "assistant")
          .map((msg) => ({
            role: msg.role,
            content: msg.content,
          })),
      );
    }

    // ⭐ 判断是否跳过计划生成阶段
    // 如果 interrupt_feedback 是 "accepted" 或 "edit_plan"，说明计划已完成，直接进入检索阶段
    const skipPlanGeneration =
      params.interrupt_feedback === "accepted" ||
      params.interrupt_feedback === "edit_plan";

    if (skipPlanGeneration) {
      // 计划已完成，直接进入检索阶段
      processingStatus.value.isPlanGenerating = false;
      processingStatus.value.isResearchInProgress = true;
      processingStatus.value.isReportGenerating = false;
      processingStatus.value.isResearchCompleted = false;
      console.log("计划已完成，直接进入检索阶段");
    } else {
      // 正常流程，开始生成计划
      processingStatus.value.isPlanGenerating = true;
      processingStatus.value.isResearchInProgress = false;
      processingStatus.value.isReportGenerating = false;
      processingStatus.value.isResearchCompleted = false;
    }

    // 用于标记是否已保存深度检索结果，避免重复保存
    let deepSearchResultSaved = false;

    // 用于跟踪上一个 researcher 的 id，用于检测新的 researcher 开始
    let lastResearcherId: string | null = null;

    // ⭐ 参数名转换：将 threadId（驼峰）转换为 thread_id（下划线）
    const apiParams = { ...params };
    if (apiParams.threadId !== undefined) {
      apiParams.thread_id = apiParams.threadId;
      delete apiParams.threadId;
    }
    // 如果没有显式传入 max_step_num，则使用默认值 3
    if (apiParams.max_step_num === undefined) {
      apiParams.max_step_num = 3;
    }

    const stream = streamDeerFlowChat({
      ...apiParams,
      messages: msgHistory, // 使用我们准备好的带系统指令的历史记录
      onMessage: (event: any) => {
        aiThinking.value = false;

        // ⭐ 关键修复：保存后端返回的真实 thread_id
        if (event.thread_id && event.thread_id !== "__default__") {
          currentThreadId.value = event.thread_id;
        }

        const lastMessage = messages.value[messages.value.length - 1];
        if (!lastMessage || lastMessage.role !== "assistant") return;

        // ⭐ 更新消息的 threadId 为真实值
        if (event.thread_id && event.thread_id !== "__default__") {
          lastMessage.threadId = event.thread_id;
        }

        switch (event.type) {
          case "content":
          case "message_chunk":
            if (event.agent) {
              lastMessage.agent = event.agent;
              lastMessage.currentAgent = event.agent;
            }

            if (event.agent) {
              // 初始化 agentContents
              if (!lastMessage.agentContents) {
                lastMessage.agentContents = {};
              }

              if (!lastMessage.agentContents[event.agent]) {
                lastMessage.agentContents[event.agent] = {
                  content: "",
                  contentChunks: [],
                  reasoningContent: "",
                  reasoningContentChunks: [],
                  isStreaming: true,
                  status: "typing",
                };
              }

              const agentContent = lastMessage.agentContents[event.agent];

              // ⭐ 关键修复：只要 agent 切换，就更新全局处理状态，而不仅仅是有 content 时
              if (event.agent === "planner" || event.agent === "coordinator") {
                processingStatus.value.isPlanGenerating = true;
                processingStatus.value.isResearchInProgress = false;
                processingStatus.value.isResearchCompleted = false;
              } else if (event.agent === "researcher") {
                processingStatus.value.isPlanGenerating = false;
                processingStatus.value.isResearchInProgress = true;
                processingStatus.value.isResearchCompleted = false;
              } else if (event.agent === "reporter") {
                processingStatus.value.isPlanGenerating = false;
                processingStatus.value.isResearchInProgress = false;
                processingStatus.value.isReportGenerating = true;
                processingStatus.value.isResearchCompleted = true;
              }

              // ⭐ 关键修复：如果是 planner 且已被用户编辑，跳过内容更新
              // 这样可以保留用户编辑的内容，不被后端返回的内容覆盖
              if (
                event.agent === "planner" &&
                agentContent &&
                agentContent.isUserEdited
              ) {
                // 跳过 planner 的内容更新，直接返回
                break;
              }

              // 处理 reasoning_content
              if (event.reasoning_content && agentContent) {
                agentContent.reasoningContent += event.reasoning_content;
                agentContent.reasoningContentChunks.push(
                  event.reasoning_content,
                );
                agentContent.status = "thinking";
                agentContent.updatedAt = new Date().toISOString();

                // 更新消息级别的 reasoningContent
                lastMessage.reasoningContent =
                  (lastMessage.reasoningContent || "") +
                  event.reasoning_content;
              }

              // 处理 content
              if (event.content && agentContent) {
                // 强制保持流式状态
                aiTyping.value = true;
                streaming.value = true;
                lastMessage.status = "typing";
                lastMessage.isStreaming = true;
                agentContent.status = "typing";
                agentContent.isStreaming = true;

                // ⭐ planner 特殊处理：保留旧展示内容，后台累积 raw；解析到新对象后直接替换（避免先清空造成闪动）
                if (event.agent === "planner") {
                  const raw = (agentContent as any)._plannerRawContent || "";
                  (agentContent as any)._plannerRawContent =
                    raw + event.content;

                  const lastObj = extractLastJsonObject(
                    (agentContent as any)._plannerRawContent,
                  );
                  if (lastObj) {
                    const rendered = JSON.stringify(lastObj, null, 2);
                    if ((agentContent as any)._plannerRendered !== rendered) {
                      (agentContent as any)._plannerRendered = rendered;
                      agentContent.content = rendered;
                      agentContent.contentChunks = [rendered];
                      lastMessage.planData = lastObj;
                    }
                  }

                  agentContent.updatedAt = new Date().toISOString();
                } else {
                  // ⭐ 检测 researcher 的 id 变化，如果检测到新的 researcher 开始，添加换行分隔
                  if (event.agent === "researcher" && event.id) {
                    if (
                      lastResearcherId !== null &&
                      lastResearcherId !== event.id
                    ) {
                      // 检测到新的 researcher 开始，如果当前内容末尾没有换行，则添加换行
                      if (
                        agentContent.content &&
                        !agentContent.content.endsWith("\n") &&
                        !agentContent.content.endsWith("\n\n")
                      ) {
                        agentContent.content += "\n\n";
                        agentContent.contentChunks.push("\n\n");
                      }
                    }
                    lastResearcherId = event.id;
                  }

                  agentContent.content += event.content;
                  agentContent.contentChunks.push(event.content);
                  agentContent.updatedAt = new Date().toISOString();
                }

                // ⭐ 检测 researcher 的 id 变化
                if (
                  lastMessage.reasoningContent &&
                  lastMessage.reasoningContent.trim()
                ) {
                  lastMessage.thoughtExpanded = false;
                }
              }

              lastMessage.updatedAt = new Date().toISOString();
            }
            break;

          case "tool_calls":
            toolCalling.value = true;
            lastMessage.status = "tool_calling";
            if (event.tool_calls && Array.isArray(event.tool_calls)) {
              if (!lastMessage.toolCalls) lastMessage.toolCalls = [];
              event.tool_calls.forEach((toolCall: any) => {
                currentToolCalls.value.push(toolCall);
                lastMessage.toolCalls!.push(toolCall);
              });
            }
            break;

          case "tool_result":
            // console.log("工具调用结果:", event);
            if (event.tool_call_id && lastMessage.toolCalls) {
              const toolCall = lastMessage.toolCalls.find(
                (tc: any) => tc.id === event.tool_call_id,
              );
              if (toolCall) {
                toolCall.result = event.content;
              }
            }
            break;

          case "interrupt":
            streaming.value = false;
            aiTyping.value = false;
            interruptPending.value = true;
            lastMessage.status = "interrupt";
            lastMessage.isStreaming = false;
            processingStatus.value.isPlanGenerating = false;
            if (event.options) {
              interruptOptions.value = event.options;
              lastMessage.options = event.options;
            }
            // console.log("收到中断事件:", event);
            break;

          case "complete":
          case "end":
            // 只有当最后一个 agent 是 reporter 时，才真正完成
            if (
              event.agent === "reporter" ||
              lastMessage.currentAgent === "reporter"
            ) {
              aiTyping.value = false;
              streaming.value = false;
              lastMessage.isStreaming = false;
              lastMessage.status = "completed";
              lastMessage.finishReason = event.finish_reason || "stop";

              if (lastMessage.agentContents) {
                Object.keys(lastMessage.agentContents).forEach((agent) => {
                  const agentContent = lastMessage.agentContents?.[agent];
                  if (agentContent) {
                    agentContent.isStreaming = false;
                    agentContent.status = "completed";
                  }
                });
              }

              currentStream.value?.close();
            } else {
              // 非 reporter agent 完成，强制保持流式状态
              streaming.value = true;
              aiTyping.value = true;
              lastMessage.status = "typing";
              lastMessage.isStreaming = true;
            }
            break;

          case "error":
            streamingError.value = event.error || "发生错误";
            lastMessage.status = "error";
            lastMessage.content = event.error || "发生错误，请重试";
            streaming.value = false;
            aiTyping.value = false;
            break;

          case "plan":
            if (event.plan) {
              lastMessage.planData = event.plan;
            }
            break;

          case "tool_call_chunks":
            // 处理工具调用块事件（静默处理，不需要额外操作）
            if (event.data) {
              console.debug("工具调用块:", event.data);
            }
            break;

          default:
            // 处理未知事件类型
            break;
        }

        // 处理 finish_reason - 根据完成原因设置状态
        if (event.finish_reason) {
          lastMessage.finishReason = event.finish_reason;

          switch (event.finish_reason) {
            case "stop":
            case "length":
              // 如果是 planner 完成，清除计划生成状态
              if (event.agent === "planner") {
                processingStatus.value.isPlanGenerating = false;
              }

              // 如果是 researcher 完成，更新状态并标记研究完成
              if (event.agent === "researcher") {
                processingStatus.value.isPlanGenerating = false;
                processingStatus.value.isResearchInProgress = true;
                processingStatus.value.isResearchCompleted = false;

                // ⭐ 在 researcher 完成时，在内容后面添加两个换行符，用于区分多个 researcher 的输出
                if (
                  lastMessage.agentContents &&
                  lastMessage.agentContents.researcher
                ) {
                  const researcherContent =
                    lastMessage.agentContents.researcher;
                  if (researcherContent.content) {
                    // 如果内容末尾没有换行或只有一个换行，则添加两个换行符
                    if (
                      !researcherContent.content.endsWith("\n\n") &&
                      !researcherContent.content.endsWith("\n\n\n")
                    ) {
                      // 如果末尾有一个换行，再添加一个；如果没有换行，添加两个
                      if (researcherContent.content.endsWith("\n")) {
                        researcherContent.content += "\n";
                        researcherContent.contentChunks.push("\n");
                      } else {
                        researcherContent.content += "\n\n";
                        researcherContent.contentChunks.push("\n\n");
                      }
                    }
                  }
                }
              }

              // 只有当 agent 是 "reporter" 时，才真正完成流式传输
              if (event.agent === "reporter") {
                // 清除报告生成状态
                processingStatus.value.isResearchCompleted = true;
                processingStatus.value.isReportGenerating = false;

                aiTyping.value = false;
                streaming.value = false;
                lastMessage.isStreaming = false;
                lastMessage.status = "completed";

                // 标记所有 agent 内容为完成
                if (lastMessage.agentContents) {
                  Object.keys(lastMessage.agentContents).forEach((agent) => {
                    const agentContent = lastMessage.agentContents?.[agent];
                    if (agentContent) {
                      agentContent.isStreaming = false;
                      agentContent.status = "completed";
                    }
                  });
                }
              } else {
                // 非 reporter agent 完成时，只更新该 agent 的状态
                if (lastMessage.agentContents && event.agent) {
                  const agentContent = lastMessage.agentContents[event.agent];
                  if (agentContent) {
                    agentContent.isStreaming = false;
                    agentContent.status = "completed";
                  }

                  // 如果是 planner 完成，标记以便前端显示操作按钮，并暂停流式状态等待用户确认
                  if (event.agent === "planner") {
                    // 如果不是自动接受计划，或者已经达到最大迭代次数（暂不支持多次迭代的 UI），则暂停
                    if (!apiParams.auto_accepted_plan) {
                      lastMessage.plannerFinished = true;
                      // 暂停流式传输，等待用户确认
                      streaming.value = false;
                      aiTyping.value = false;
                      lastMessage.status = "planner_waiting_confirmation";
                      lastMessage.isStreaming = false;

                      // 再次确保 planner 的 isStreaming 被设置为 false
                      if (agentContent) {
                        agentContent.isStreaming = false;
                        agentContent.status = "completed";
                      }
                      return; // 直接返回，不再继续执行后续逻辑
                    } else {
                      // 如果是自动接受计划，标记 planner 已完成，但不暂停流式传输
                      lastMessage.plannerFinished = true;
                      if (agentContent) {
                        agentContent.isStreaming = false;
                        agentContent.status = "completed";
                      }
                    }
                  }
                }

                // ⚠️ 关键：其他 agent 完成时，强制保持整体流式状态
                streaming.value = true;
                aiTyping.value = true;
                lastMessage.status = "typing";
                lastMessage.isStreaming = true;
              }
              break;

            case "tool_calls":
              lastMessage.status = "tool_calling";
              if (lastMessage.agentContents && event.agent) {
                const agentContent = lastMessage.agentContents[event.agent];
                if (agentContent) {
                  agentContent.isStreaming = false;
                  agentContent.status = "tool_calling";
                }
              }
              break;

            case "interrupt":
              streaming.value = false;
              aiTyping.value = false;
              interruptPending.value = true;
              lastMessage.status = "interrupt";
              lastMessage.isStreaming = false;
              break;
          }
        }
      },
      onError: (err: any) => {
        console.error("DeerFlow 流式错误:", err);
        streamingError.value = err.message || "连接失败";
        streaming.value = false;
        aiThinking.value = false;
        aiTyping.value = false;

        const lastMessage = messages.value[messages.value.length - 1];
        if (lastMessage) {
          lastMessage.status = "error";
          lastMessage.content = "连接失败，请重试";
        }

        // 清除加载状态
        setCurrentRunningTaskId(null);
      },
      onComplete: async () => {
        // 触发新手任务：深度检索
        triggerNewbieTask("deep_search_report");

        const lastMessage = messages.value[messages.value.length - 1];

        // 检查最后一个 agent 是否是 reporter
        if (lastMessage && lastMessage.currentAgent === "reporter") {
          streaming.value = false;
          aiThinking.value = false;
          aiTyping.value = false;
          lastMessage.status = "completed";
          lastMessage.isStreaming = false;

          // 保存深度检索结果（带完整数据）- 避免重复保存
          if (!deepSearchResultSaved) {
            deepSearchResultSaved = true;
            try {
              // 查找最近的用户消息作为 question
              let question = "";
              for (let i = messages.value.length - 1; i >= 0; i--) {
                const msg = messages.value[i];
                if (msg && msg.role === "user") {
                  question = msg.content;
                  break;
                }
              }

              if (question) {
                // 将 messages 转换为 JSON 作为 data
                const messagesData = JSON.parse(JSON.stringify(messages.value));

                // 从 reporter 内容中提取标题
                const reporterContent =
                  lastMessage.agentContents?.reporter?.content || "";
                const title = extractTitleFromMarkdown(reporterContent);

                // 传递第一次保存时返回的 ID、提取的标题和 thread_id
                const savedResult = await saveDeepSearch(
                  question,
                  messagesData,
                  currentRunningTaskId.value || undefined,
                  title || undefined,
                  currentThreadId.value || undefined,
                  schedulesStore.scheduleId || undefined,
                );
                
                // 更新当前任务 ID，以便后续操作（如反馈）使用
                if (savedResult && savedResult.id) {
                  setCurrentRunningTaskId(savedResult.id);
                  lastMessage.deepSearchId = savedResult.id;
                }
              }
            } catch (error) {
              console.error("保存深度检索结果失败:", error);
              // 保存失败不影响正常流程
            }
          }

          // 清除加载状态
          setCurrentRunningTaskId(null);
        } else if (lastMessage && lastMessage.currentAgent === "planner") {
          // ⭐ 关键修复：如果 planner 完成且流结束
          // 如果不是自动接受计划，设置状态等待用户确认
          if (!apiParams.auto_accepted_plan) {
            lastMessage.plannerFinished = true;
            streaming.value = false;
            aiTyping.value = false;
            lastMessage.status = "planner_waiting_confirmation";
            lastMessage.isStreaming = false;
          } else {
            // 如果是自动接受计划，但流却结束了，这通常不应该发生（除非后端异常）
            // 这里标记为已完成，避免卡在打字状态
            lastMessage.plannerFinished = true;
            streaming.value = false;
            aiTyping.value = false;
            lastMessage.status = "completed";
            lastMessage.isStreaming = false;
          }

          // 确保 planner 的 isStreaming 被设置为 false
          if (lastMessage.agentContents?.planner) {
            lastMessage.agentContents.planner.isStreaming = false;
            lastMessage.agentContents.planner.status = "completed";
          }
          // 清除计划生成状态
          processingStatus.value.isPlanGenerating = false;
        } else {
          // 如果不是 reporter 完成，可能是流异常结束，强制完成
          streaming.value = false;
          aiThinking.value = false;
          aiTyping.value = false;
          if (lastMessage) {
            lastMessage.status = "completed";
            lastMessage.isStreaming = false;
          }

          // 清除加载状态
          // setCurrentRunningTaskId(null);
        }
      },
    });

    currentStream.value = stream;
  }

  // 停止流式请求
  function stopStreaming() {
    if (currentStream.value) {
      // 只有在真正的活跃流（非历史回放）中才通知后端终止
      if (streaming.value && !isReplayStreaming.value && currentThreadId.value) {
        console.log("通知后端终止流式请求:", currentThreadId.value);
        cancelChat(currentThreadId.value).catch((err) => {
          console.warn("通知后端终止流式请求失败:", err);
        });
      }

      try {
        currentStream.value.close();
        console.log("流已关闭！");
        currentStream.value = null;
      } catch (e) {
        console.warn("关闭流式请求失败:", e);
      }
    }
    streaming.value = false;
    isReplayStreaming.value = false;
    aiThinking.value = false;
    aiTyping.value = false;
    streamingError.value = null;

    // UI 状态闭环：将最后一条消息标记为完成，避免卡在思考/输入状态
    if (messages.value.length > 0) {
      const lastMessage = messages.value[messages.value.length - 1];
      if (lastMessage && lastMessage.role === 'assistant') {
        if (['thinking', 'typing', 'pending', 'streaming', 'plan_generating', 'researching', 'reporting'].includes(lastMessage.status || '')) {
          lastMessage.status = 'completed';
          lastMessage.isStreaming = false;
        }
      }
    }

    // 重置深度检索相关的状态
    processingStatus.value = {
      isPlanGenerating: false,
      isResearchInProgress: false,
      isReportGenerating: false,
      isResearchCompleted: false,
    };
    currentRunningTaskId.value = null;
    currentThreadId.value = null;
  }

  function clearMessages() {
    messages.value = [];
  }

  function setThreadId(threadId: string) {
    currentThreadId.value = threadId;
  }

  function toggleThoughtExpanded(messageId: string) {
    const message = messages.value.find((msg) => msg.id === messageId);
    if (message) {
      message.thoughtExpanded = !message.thoughtExpanded;
    }
  }

  async function sendInterruptResponse(_response: string) {
    try {
      // TODO: 实现中断响应逻辑
      interruptPending.value = false;
      interruptOptions.value = [];
    } catch (error) {
      console.error("发送中断响应失败:", error);
    }
  }

  /**
   * 加载历史深度检索任务-后端已跑完，前端直接加载历史数据
   * @param taskDetail - 深度检索任务详情
   */
  function loadHistoryTask(taskDetail: any) {
    // 设置处理状态（任务已完成，不在进行中）
    processingStatus.value.isPlanGenerating = false;
    processingStatus.value.isResearchInProgress = false;
    processingStatus.value.isReportGenerating = false;
    processingStatus.value.isResearchCompleted = true;
    try {
      // 清空当前消息
      messages.value = [];
      // 解析 data 字段
      if (taskDetail.data) {
        let parsedData = taskDetail.data;

        // 尝试解析 JSON 字符串
        if (typeof taskDetail.data === "string") {
          try {
            parsedData = JSON.parse(taskDetail.data);
          } catch (e) {
            console.warn("⚠️ 无法解析 data 字段为 JSON，使用原始数据");
          }
        }

        // data 是一个数组，包含消息对象
        if (Array.isArray(parsedData)) {
          // 遍历每个消息
          parsedData.forEach((msgData: any, index: number) => {
            if (!msgData || typeof msgData !== "object") {
              console.warn(`❌ 消息 ${index} 格式不正确`, msgData);
              return;
            }

            // 创建消息对象
            const message: DeerFlowMessage = {
              id: msgData.id || `msg_${Date.now()}_${index}`,
              role: msgData.role || "assistant",
              content: msgData.content || "",
              createdAt:
                msgData.createdAt ||
                taskDetail.createdAt ||
                new Date().toISOString(),
              status: msgData.status || "completed",
              agentContents: {},
              threadId: msgData.threadId,
              agent: msgData.agent,
              currentAgent: msgData.currentAgent,
              plannerFinished: msgData.plannerFinished,
              finishReason: msgData.finishReason,
              isStreaming: false,
              planData: msgData.planData || null,
              deepSearchId: taskDetail.id, // 关键修复：从任务详情中获取后端 ID
            };

            // 如果是用户消息，直接添加
            if (msgData.role === "user") {
              messages.value.push(message);
              return;
            }

            // 如果是 AI 消息，处理 agentContents
            if (
              msgData.agentContents &&
              typeof msgData.agentContents === "object"
            ) {
              const agentKeys = Object.keys(msgData.agentContents);

              // 复制 agentContents
              agentKeys.forEach((agentKey) => {
                const agentData = msgData.agentContents[agentKey];

                message.agentContents![agentKey] = {
                  content: agentData.content || "",
                  contentChunks: agentData.contentChunks || [],
                  reasoningContent: agentData.reasoningContent || "",
                  reasoningContentChunks:
                    agentData.reasoningContentChunks || [],
                  isStreaming: false,
                  status: agentData.status || "completed",
                };
              });
            }

            messages.value.push(message);
          });
        }
      }
    } catch (error) {
      console.error("❌ 加载历史任务失败:", error);
      throw error;
    }
  }

  /**
   * 重新执行未完成的深度检索任务（使用 replayChatStream）
   * @param taskDetail - 深度检索任务详情
   */
  async function replayHistoryTask(taskDetail: any, signal?: AbortSignal) {
    try {
      // 先重置所有处理状态，避免沿用之前的状态
      processingStatus.value.isPlanGenerating = false;
      processingStatus.value.isResearchInProgress = false;
      processingStatus.value.isReportGenerating = false;
      processingStatus.value.isResearchCompleted = false;
      streaming.value = false;
      aiThinking.value = false;
      aiTyping.value = false;

      // 清空当前消息
      messages.value = [];

      // 设置深度检索ID和线程ID
      if (taskDetail.id) {
        // 设置当前运行任务ID，显示加载中图标
        setCurrentRunningTaskId(taskDetail.id);
      }
      if (taskDetail.threadId) {
        currentThreadId.value = taskDetail.threadId;
      }

      // ⭐ 如果后端 status.interrupted === false，说明已“继续/接受”过计划，应直接按“检索中”展示
      // 避免 UI 误显示“计划生成中/等待确认”
      if (
        taskDetail.threadId &&
        getThreadInterrupted(taskDetail.threadId) === false
      ) {
        processingStatus.value.isPlanGenerating = false;
        processingStatus.value.isResearchInProgress = true;
        processingStatus.value.isReportGenerating = false;
        processingStatus.value.isResearchCompleted = false;
      }

      // 添加用户消息
      const userMessage: DeerFlowMessage = {
        id: `msg_${Date.now()}`,
        role: "user",
        content: taskDetail.question || "",
        createdAt: taskDetail.createdAt || new Date().toISOString(),
        threadId: taskDetail.threadId,
      };
      messages.value.push(userMessage);

      // 添加 AI 响应占位符
      const aiMessage: DeerFlowMessage = {
        id: `msg_${Date.now() + 1}`,
        role: "assistant",
        agent: null,
        content: "",
        contentChunks: [],
        reasoningContent: "",
        reasoningContentChunks: [],
        createdAt: new Date().toISOString(),
        threadId: taskDetail.threadId,
        status: "thinking",
        thoughtExpanded: true,
        finishReason: null,
        options: null,
        isStreaming: true,
        toolCalls: [],
        agentContents: {},
        deepSearchId: taskDetail.id, // 关键修复：从任务详情中获取后端 ID
      };
      messages.value.push(aiMessage);
      // 开始重放流式对话
      await replayStreaming(taskDetail.threadId, signal);
    } catch (error: any) {
      // 重置所有处理状态
      processingStatus.value.isPlanGenerating = false;
      processingStatus.value.isResearchInProgress = false;
      processingStatus.value.isReportGenerating = false;
      processingStatus.value.isResearchCompleted = false;
      streaming.value = false;
      aiThinking.value = false;
      aiTyping.value = false;
      streamingError.value = error.message || "重新执行失败";
      const lastMessage = messages.value[messages.value.length - 1];
      if (lastMessage) {
        lastMessage.status = "error";
        lastMessage.content = "重新执行失败，请重试";
      }
      // 清除加载状态
      setCurrentRunningTaskId(null);
    }
  }

  /**
   * 重放流式对话
   * @param threadId - 线程ID
   */
  async function replayStreaming(threadId: string, signal?: AbortSignal) {
    // 关闭之前的流
    if (currentStream.value) {
      try {
        currentStream.value.close();
      } catch (e) {
        console.warn("关闭之前的流失败:", e);
      }
    }

    streaming.value = true;
    isReplayStreaming.value = true;
    streamingError.value = null;
    aiThinking.value = true;
    // processingStatus.value.isPlanGenerating = true;

    // 用于标记是否已保存深度检索结果，避免重复保存
    let deepSearchResultSaved = false;

    // 用于跟踪上一个 researcher 的 id，用于检测新的 researcher 开始
    let lastResearcherId: string | null = null;

    // 导入 replayChatStream
    const { replayChatStream } = await import("@/api/deerflow");

    const stream = replayChatStream(
      threadId,
      (event: any) => {
        aiThinking.value = false;

        // ⭐ 关键修复：保存后端返回的真实 thread_id
        if (event.thread_id && event.thread_id !== "__default__") {
          currentThreadId.value = event.thread_id;
        }

        const lastMessage = messages.value[messages.value.length - 1];
        if (!lastMessage || lastMessage.role !== "assistant") return;

        // ⭐ 更新消息的 threadId 为真实值
        if (event.thread_id && event.thread_id !== "__default__") {
          lastMessage.threadId = event.thread_id;
        }
        switch (event.type) {
          case "content":
          case "message_chunk":
            if (event.agent) {
              lastMessage.agent = event.agent;
              lastMessage.currentAgent = event.agent;
            }

            if (event.agent) {
              // 初始化 agentContents
              if (!lastMessage.agentContents) {
                lastMessage.agentContents = {};
              }

              if (!lastMessage.agentContents[event.agent]) {
                lastMessage.agentContents[event.agent] = {
                  content: "",
                  contentChunks: [],
                  reasoningContent: "",
                  reasoningContentChunks: [],
                  isStreaming: true,
                  status: "typing",
                };
              }

              const agentContent = lastMessage.agentContents[event.agent];

              // ⭐ 关键修复：只要 agent 切换，就更新全局处理状态，而不仅仅是有 content 时
              if (event.agent === "planner" || event.agent === "coordinator") {
                processingStatus.value.isPlanGenerating = true;
                processingStatus.value.isResearchInProgress = false;
                processingStatus.value.isResearchCompleted = false;
              } else if (event.agent === "researcher") {
                processingStatus.value.isPlanGenerating = false;
                processingStatus.value.isResearchInProgress = true;
                processingStatus.value.isResearchCompleted = false;
              } else if (event.agent === "reporter") {
                processingStatus.value.isPlanGenerating = false;
                processingStatus.value.isResearchInProgress = false;
                processingStatus.value.isReportGenerating = true;
                processingStatus.value.isResearchCompleted = true;
              }

              // 处理 reasoning_content
              if (event.reasoning_content && agentContent) {
                agentContent.reasoningContent += event.reasoning_content;
                agentContent.reasoningContentChunks.push(
                  event.reasoning_content,
                );
                agentContent.status = "thinking";
                agentContent.updatedAt = new Date().toISOString();

                // 更新消息级别的 reasoningContent
                lastMessage.reasoningContent =
                  (lastMessage.reasoningContent || "") +
                  event.reasoning_content;
              }

              // 处理 content
              if (event.content && agentContent) {
                // ⚠️ 关键：恢复状态更新，确保界面正确显示
                aiTyping.value = true;
                streaming.value = true;
                lastMessage.status = "typing";
                lastMessage.isStreaming = true;
                agentContent.status = "typing";
                agentContent.isStreaming = true;

                // ⭐ planner 特殊处理：保留旧展示内容，后台累积 raw；解析到新对象后直接替换（避免先清空造成闪动）
                if (event.agent === "planner") {
                  const raw = (agentContent as any)._plannerRawContent || "";
                  (agentContent as any)._plannerRawContent =
                    raw + event.content;

                  const lastObj = extractLastJsonObject(
                    (agentContent as any)._plannerRawContent,
                  );
                  if (lastObj) {
                    const rendered = JSON.stringify(lastObj, null, 2);
                    if ((agentContent as any)._plannerRendered !== rendered) {
                      (agentContent as any)._plannerRendered = rendered;
                      agentContent.content = rendered;
                      agentContent.contentChunks = [rendered];
                      lastMessage.planData = lastObj;
                    }
                  }

                  agentContent.updatedAt = new Date().toISOString();
                } else {
                  // ⭐ 检测 researcher 的 id 变化，如果检测到新的 researcher 开始，添加换行分隔
                  if (event.agent === "researcher" && event.id) {
                    if (
                      lastResearcherId !== null &&
                      lastResearcherId !== event.id
                    ) {
                      // 检测到新的 researcher 开始，如果当前内容末尾没有换行，则添加换行
                      if (
                        agentContent.content &&
                        !agentContent.content.endsWith("\n") &&
                        !agentContent.content.endsWith("\n\n")
                      ) {
                        agentContent.content += "\n\n";
                        agentContent.contentChunks.push("\n\n");
                      }
                    }
                    lastResearcherId = event.id;
                  }

                  agentContent.content += event.content;
                  agentContent.contentChunks.push(event.content);
                  agentContent.updatedAt = new Date().toISOString();
                }

                // ⭐ 检测 researcher 的 id 变化
                if (
                  lastMessage.reasoningContent &&
                  lastMessage.reasoningContent.trim()
                ) {
                  lastMessage.thoughtExpanded = false;
                }
              }

              lastMessage.updatedAt = new Date().toISOString();
            }
            break;

          case "tool_calls":
            toolCalling.value = true;
            lastMessage.status = "tool_calling";
            if (event.tool_calls && Array.isArray(event.tool_calls)) {
              if (!lastMessage.toolCalls) lastMessage.toolCalls = [];
              event.tool_calls.forEach((toolCall: any) => {
                currentToolCalls.value.push(toolCall);
                lastMessage.toolCalls!.push(toolCall);
              });
            }
            break;

          case "tool_result":
            if (event.tool_call_id && lastMessage.toolCalls) {
              const toolCall = lastMessage.toolCalls.find(
                (tc: any) => tc.id === event.tool_call_id,
              );
              if (toolCall) {
                toolCall.result = event.content;
              }
            }
            break;

          case "interrupt":
            streaming.value = false;
            aiTyping.value = false;
            interruptPending.value = true;
            lastMessage.status = "interrupt";
            lastMessage.isStreaming = false;
            processingStatus.value.isPlanGenerating = false;
            if (event.options) {
              interruptOptions.value = event.options;
              lastMessage.options = event.options;
            }
            break;

          case "complete":
          case "end":
            if (
              event.agent === "reporter" ||
              lastMessage.currentAgent === "reporter"
            ) {
              aiTyping.value = false;
              streaming.value = false;
              lastMessage.isStreaming = false;
              lastMessage.status = "completed";
              lastMessage.finishReason = event.finish_reason || "stop";

              if (lastMessage.agentContents) {
                Object.keys(lastMessage.agentContents).forEach((agent) => {
                  const agentContent = lastMessage.agentContents?.[agent];
                  if (agentContent) {
                    agentContent.isStreaming = false;
                    agentContent.status = "completed";
                  }
                });
              }

              currentStream.value?.close();
            } else {
              streaming.value = true;
              aiTyping.value = true;
              lastMessage.status = "typing";
              lastMessage.isStreaming = true;
            }
            break;

          case "error":
            streamingError.value = event.error || "发生错误";
            lastMessage.status = "error";
            lastMessage.content = event.error || "发生错误，请重试";
            streaming.value = false;
            aiTyping.value = false;
            break;

          case "plan":
            if (event.plan) {
              lastMessage.planData = event.plan;
            }
            break;

          case "tool_call_chunks":
            if (event.data) {
              console.debug("工具调用块:", event.data);
            }
            break;

          default:
            break;
        }

        // 处理 finish_reason
        if (event.finish_reason) {
          lastMessage.finishReason = event.finish_reason;

          switch (event.finish_reason) {
            case "stop":
            case "length":
              // 使用 if-else if 结构，确保只进入一个分支
              if (event.agent === "reporter") {
                // ========== Reporter 完成 ==========
                processingStatus.value.isReportGenerating = false;
                aiTyping.value = false;
                streaming.value = false;
                lastMessage.isStreaming = false;
                lastMessage.status = "completed";

                if (lastMessage.agentContents) {
                  Object.keys(lastMessage.agentContents).forEach((agent) => {
                    const agentContent = lastMessage.agentContents?.[agent];
                    if (agentContent) {
                      agentContent.isStreaming = false;
                      agentContent.status = "completed";
                    }
                  });
                }

                // 保存深度检索结果
                if (!deepSearchResultSaved) {
                  deepSearchResultSaved = true;
                  (async () => {
                    try {
                      let question = "";
                      for (let i = messages.value.length - 1; i >= 0; i--) {
                        const msg = messages.value[i];
                        if (msg && msg.role === "user") {
                          question = msg.content;
                          break;
                        }
                      }

                      if (question) {
                        const messagesData = JSON.parse(
                          JSON.stringify(messages.value),
                        );

                        const reporterContent =
                          lastMessage.agentContents?.reporter?.content || "";
                        const title = extractTitleFromMarkdown(reporterContent);

                        const savedResult = await saveDeepSearch(
                          question,
                          messagesData,
                          currentRunningTaskId.value || undefined,
                          title || undefined,
                          currentThreadId.value || undefined,
                          schedulesStore.scheduleId || undefined,
                        );

                        if (savedResult && savedResult.id) {
                          setCurrentRunningTaskId(savedResult.id);
                          lastMessage.deepSearchId = savedResult.id;
                        }
                      }
                    } catch (error) {
                      console.error("保存深度检索结果失败:", error);
                    }
                  })();
                }
              } else if (event.agent === "researcher") {
                // ========== Researcher 完成 ==========
                processingStatus.value.isPlanGenerating = false;
                processingStatus.value.isResearchInProgress = true;
                processingStatus.value.isResearchCompleted = false;

                // 设置该 researcher 的内容状态为完成
                if (lastMessage.agentContents && event.agent) {
                  const agentContent = lastMessage.agentContents[event.agent];
                  if (agentContent) {
                    agentContent.isStreaming = false;
                    agentContent.status = "completed";

                    // ⭐ 在 researcher 内容后面添加两个换行符，用于区分多个 researcher 的输出
                    if (agentContent.content) {
                      // 如果内容末尾没有换行或只有一个换行，则添加两个换行符
                      if (
                        !agentContent.content.endsWith("\n\n") &&
                        !agentContent.content.endsWith("\n\n\n")
                      ) {
                        // 如果末尾有一个换行，再添加一个；如果没有换行，添加两个
                        if (agentContent.content.endsWith("\n")) {
                          agentContent.content += "\n";
                          agentContent.contentChunks.push("\n");
                        } else {
                          agentContent.content += "\n\n";
                          agentContent.contentChunks.push("\n\n");
                        }
                      }
                    }
                  }
                }

                // ⚠️ 关键：researcher 完成后，保持流式状态等待 reporter
                streaming.value = true;
                aiTyping.value = true;
                lastMessage.isStreaming = true;
                // 注意：不修改 lastMessage.status，保持当前状态
                  } else if (event.agent === "planner") {
                    // ========== Planner 完成 ==========
                    processingStatus.value.isPlanGenerating = false;
                    if (lastMessage.agentContents && event.agent) {
                      const agentContent = lastMessage.agentContents[event.agent];
                      if (agentContent) {
                        agentContent.isStreaming = false;
                        agentContent.status = "completed";

                        // ⭐ 特殊处理：planner 可能返回多个对象（如 "{}{...}"），取最后一个对象用于展示与 planData
                        if (agentContent.content) {
                          const lastObj = extractLastJsonObject(
                            agentContent.content,
                          );
                          if (lastObj) {
                            try {
                              // 不先清空，直接在确实解析到新对象时替换
                              const rendered = JSON.stringify(lastObj, null, 2);
                              if (
                                (agentContent as any)._plannerRendered !== rendered
                              ) {
                                (agentContent as any)._plannerRendered = rendered;
                                agentContent.content = rendered;
                                agentContent.contentChunks = [rendered];
                              }
                              lastMessage.planData = lastObj;
                            } catch {
                              // JSON.stringify 理论上不会失败，这里兜底不影响流程
                              lastMessage.planData = lastObj;
                            }
                          }
                        }

                        // 如果不是自动接受计划，则暂停等待用户确认
                        // 注意：在重放模式下，我们目前无法获取到原始的 auto_accepted_plan 参数，
                        // 但通常重放的是正在进行的任务，我们可以根据 threadId 缓存的状态来判断
                        const isAutoAccepted = getThreadInterrupted(threadId) === false;

                        if (!isAutoAccepted) {
                          lastMessage.plannerFinished = true;
                          streaming.value = false;
                          aiTyping.value = false;
                          lastMessage.status = "planner_waiting_confirmation";
                          lastMessage.isStreaming = false;
                          return;
                        } else {
                          // 自动接受，继续流式传输
                          lastMessage.plannerFinished = true;
                          lastMessage.status = "typing";
                          lastMessage.isStreaming = true;
                        }
                      }
                    }
                  }
              break;

            case "tool_calls":
              lastMessage.status = "tool_calling";
              if (lastMessage.agentContents && event.agent) {
                const agentContent = lastMessage.agentContents[event.agent];
                if (agentContent) {
                  agentContent.isStreaming = false;
                  agentContent.status = "tool_calling";
                }
              }
              break;

            case "interrupt":
              streaming.value = false;
              aiTyping.value = false;
              interruptPending.value = true;
              lastMessage.status = "interrupt";
              lastMessage.isStreaming = false;
              break;
          }
        }
      },
      (err: any) => {
        console.error("Replay 流式错误:", err);
        streamingError.value = err.message || "连接失败";
        streaming.value = false;
        aiThinking.value = false;
        aiTyping.value = false;

        const lastMessage = messages.value[messages.value.length - 1];
        if (lastMessage) {
          lastMessage.status = "error";
          lastMessage.content = "连接失败，请重试";
        }

        // 清除加载状态
        setCurrentRunningTaskId(null);
      },
      async () => {
        const lastMessage = messages.value[messages.value.length - 1];

        if (lastMessage && lastMessage.currentAgent === "reporter") {
          streaming.value = false;
          aiThinking.value = false;
          aiTyping.value = false;
          lastMessage.status = "completed";
          lastMessage.isStreaming = false;

          // 保存深度检索结果
          if (!deepSearchResultSaved) {
            deepSearchResultSaved = true;
            try {
              let question = "";
              for (let i = messages.value.length - 1; i >= 0; i--) {
                const msg = messages.value[i];
                if (msg && msg.role === "user") {
                  question = msg.content;
                  break;
                }
              }

              if (question) {
                const messagesData = JSON.parse(JSON.stringify(messages.value));

                const reporterContent =
                  lastMessage.agentContents?.reporter?.content || "";
                const title = extractTitleFromMarkdown(reporterContent);

                const savedResult = await saveDeepSearch(
                  question,
                  messagesData,
                  currentRunningTaskId.value || undefined,
                  title || undefined,
                  currentThreadId.value || undefined,
                  schedulesStore.scheduleId || undefined,
                );

                if (savedResult && savedResult.id) {
                  setCurrentRunningTaskId(savedResult.id);
                  lastMessage.deepSearchId = savedResult.id;
                }
              }
            } catch (error) {
              console.error("保存深度检索结果失败:", error);
            }
          }

          // 清除加载状态
          setCurrentRunningTaskId(null);
        } else if (lastMessage && lastMessage.currentAgent === "planner") {
          lastMessage.plannerFinished = true;
          // 重放模式下，通过 threadId 状态判断
          const isAutoAccepted = getThreadInterrupted(threadId) === false;

          if (!isAutoAccepted) {
            streaming.value = false;
            aiTyping.value = false;
            lastMessage.status = "planner_waiting_confirmation";
            lastMessage.isStreaming = false;
          } else {
            streaming.value = false;
            aiTyping.value = false;
            lastMessage.status = "completed";
            lastMessage.isStreaming = false;
          }

          if (lastMessage.agentContents?.planner) {
            lastMessage.agentContents.planner.isStreaming = false;
            lastMessage.agentContents.planner.status = "completed";
          }
          // 清除计划生成状态
          processingStatus.value.isPlanGenerating = false;
        } else {
          streaming.value = false;
          aiThinking.value = false;
          aiTyping.value = false;
          if (lastMessage) {
            lastMessage.status = "completed";
            lastMessage.isStreaming = false;
          }
        }
      },
      signal,
    );

    currentStream.value = stream;
  }

  // 设置当前正在执行的会话 ID
  function setCurrentRunningTaskId(taskId: number | null) {
    currentRunningTaskId.value = taskId;
  }

  /**
   * 解析 SSE 格式的消息字符串
   * @param sseMessage - SSE 格式的消息字符串
   * @returns 解析后的事件对象，包含 eventType 和 data
   */
  function parseSSEMessage(sseMessage: string): {
    eventType: string;
    data: any;
  } | null {
    try {
      // 移除首尾空白
      const trimmed = sseMessage.trim();
      if (!trimmed) return null;

      // 解析 event 和 data 行
      const lines = trimmed.split("\n");
      let eventType = "";
      let dataStr = "";

      for (const line of lines) {
        if (line.startsWith("event:")) {
          eventType = line.substring(6).trim();
        } else if (line.startsWith("data:")) {
          dataStr = line.substring(5).trim();
        }
      }

      if (!dataStr) return null;

      // 解析 JSON 数据
      const data = JSON.parse(dataStr);
      return { eventType, data };
    } catch (error) {
      console.warn("解析 SSE 消息失败:", error, sseMessage);
      return null;
    }
  }

  /**
   * 加载历史聊天记录（解析 SSE 格式数据）
   * @param params - 包含 threadId、taskId 和 question 的对象
   */
  async function loadChatHistory(params: {
    threadId: string;
    sessionId?: number;
    question?: string;
    signal?: AbortSignal;
  }) {
    // 设置处理状态（任务已完成，不在进行中）
    processingStatus.value.isPlanGenerating = false;
    processingStatus.value.isResearchInProgress = false;
    processingStatus.value.isReportGenerating = false;
    processingStatus.value.isResearchCompleted = true;
    // 标记加载完成
    streaming.value = false;
    aiThinking.value = false;
    aiTyping.value = false;
    processingStatus.value.isResearchCompleted = true;
    try {
      // 清空当前消息
      messages.value = [];

      // 设置深度检索ID和线程ID
      if (params.threadId) {
        currentThreadId.value = params.threadId;
      }

      // 添加用户消息
      const userMessage: DeerFlowMessage = {
        id: `msg_${Date.now()}`,
        role: "user",
        content: params.question || "",
        createdAt: new Date().toISOString(),
        threadId: params.threadId,
      };
      messages.value.push(userMessage);

      // 导入 getChatHistory 接口
      const { getChatHistory } = await import("@/api/deerflow");

      // 调用 getChatHistory 获取历史记录
      const historyResponse = await getChatHistory(
        params.threadId,
        params.signal,
      );

      // 解析历史数据
      if (
        historyResponse &&
        historyResponse.messages &&
        Array.isArray(historyResponse.messages)
      ) {
        // 添加 AI 响应消息（用于存储所有 agent 的内容）
        const aiMessage: DeerFlowMessage = {
          id: `msg_${Date.now() + 1}`,
          role: "assistant",
          agent: null,
          content: "",
          createdAt: new Date().toISOString(),
          threadId: params.threadId,
          status: "completed",
          agentContents: {},
          isStreaming: false,
          contentChunks: [],
          reasoningContent: "",
          reasoningContentChunks: [],
          planData: null,
        };

        // 遍历所有 SSE 消息并解析
        for (const sseMessage of historyResponse.messages) {
          const parsed = parseSSEMessage(sseMessage);
          if (!parsed) continue;

          const { eventType, data } = parsed;

          // 根据事件类型处理数据
          switch (eventType) {
            case "message_chunk":
              // 处理用户消息
              if (data.role === "user") {
                // 用户消息已在上面添加，这里跳过
                break;
              }

              // 处理 AI 消息（assistant）
              if (data.agent) {
                aiMessage.currentAgent = data.agent;

                // 初始化 agent 内容
                if (!aiMessage.agentContents![data.agent]) {
                  aiMessage.agentContents![data.agent] = {
                    content: "",
                    contentChunks: [],
                    reasoningContent: "",
                    reasoningContentChunks: [],
                    isStreaming: false,
                    status: "completed",
                  };
                }

                const agentContent = aiMessage.agentContents![data.agent];
                if (agentContent) {
                  // 累积内容
                  if (data.content) {
                    agentContent.content += data.content;
                    agentContent.contentChunks.push(data.content);
                  }

                  // 累积推理内容
                  if (data.reasoning_content) {
                    agentContent.reasoningContent += data.reasoning_content;
                    agentContent.reasoningContentChunks.push(
                      data.reasoning_content,
                    );
                  }

                  agentContent.updatedAt = new Date().toISOString();
                }
              }
              break;

            case "tool_calls":
              // 处理工具调用
              if (data.tool_calls && Array.isArray(data.tool_calls)) {
                if (!aiMessage.toolCalls) aiMessage.toolCalls = [];
                aiMessage.toolCalls.push(...data.tool_calls);
              }
              break;

            case "tool_call_result":
              // 处理工具调用结果
              if (data.tool_call_id && aiMessage.toolCalls) {
                const toolCall = aiMessage.toolCalls.find(
                  (tc: any) => tc.id === data.tool_call_id,
                );
                if (toolCall) {
                  toolCall.result = data.content;
                }
              }
              break;

            case "plan":
              // 处理计划数据
              if (data.plan) {
                aiMessage.planData = data.plan;
              } else if (data) {
                // 有些情况下，plan 数据直接在 data 中
                aiMessage.planData = data;
              }
              break;

            case "tool_call_chunks":
              // 处理工具调用块事件（静默处理）
              if (data) {
                console.debug("工具调用块:", data);
              }
              break;

            default:
              // 其他事件类型暂时不处理
              break;
          }

          // 处理 finish_reason
          if (data.finish_reason) {
            aiMessage.finishReason = data.finish_reason;

            // 根据 agent 更新状态
            if (data.agent && aiMessage.agentContents![data.agent]) {
              const agentContent = aiMessage.agentContents![data.agent];
              if (agentContent) {
                agentContent.status = "completed";
                agentContent.isStreaming = false;

                // 如果是 planner 完成，标记 plannerFinished 并尝试解析 planData
                if (data.agent === "planner") {
                  aiMessage.plannerFinished = true;

                  // 如果 planData 还未设置，尝试从 planner 的 content 中解析
                  if (!aiMessage.planData && agentContent.content) {
                    try {
                      const lastObj = extractLastJsonObject(
                        agentContent.content,
                      );
                      if (lastObj) {
                        aiMessage.planData = lastObj;
                        // 同步把展示内容也规整为最后一个对象，避免 UI 显示两个 "{}"
                        agentContent.content = JSON.stringify(lastObj, null, 2);
                      }
                    } catch (e) {
                      console.warn(
                        "内容前100字符:",
                        agentContent.content.substring(0, 100),
                      );
                    }
                  }
                }

                // ⭐ 如果是 researcher 完成，在内容后面添加两个换行符，用于区分多个 researcher 的输出
                if (data.agent === "researcher") {
                  if (agentContent.content) {
                    // 如果内容末尾没有换行或只有一个换行，则添加两个换行符
                    if (
                      !agentContent.content.endsWith("\n\n") &&
                      !agentContent.content.endsWith("\n\n\n")
                    ) {
                      // 如果末尾有一个换行，再添加一个；如果没有换行，添加两个
                      if (agentContent.content.endsWith("\n")) {
                        agentContent.content += "\n";
                        agentContent.contentChunks.push("\n");
                      } else {
                        agentContent.content += "\n\n";
                        agentContent.contentChunks.push("\n\n");
                      }
                    }
                  }
                }
              }
            }
          }
        }

        // 将 AI 消息添加到消息列表
        messages.value.push(aiMessage);
        if (aiMessage.agentContents) {
          Object.keys(aiMessage.agentContents).forEach((agentKey) => {
            const agentContent = aiMessage.agentContents![agentKey];
            if (agentContent) {
            }
          });
        }
      }

      // 调用 saveDeepSearch 保存深度检索结果
      try {
        const question = params.question || "";
        if (question) {
          // 将 messages 转换为 JSON 作为 data
          const messagesData = JSON.parse(JSON.stringify(messages.value));

          // 从 reporter 内容中提取标题
          const lastMessage = messages.value[messages.value.length - 1];
          const reporterContent =
            lastMessage?.agentContents?.reporter?.content || "";
          const title = extractTitleFromMarkdown(reporterContent);

          // 调用 saveDeepSearch 保存
          const savedResult = await saveDeepSearch(
            question,
            messagesData,
            params.sessionId || undefined,
            title || undefined,
            params.threadId || undefined,
            schedulesStore.scheduleId || undefined,
          );

          if (savedResult && savedResult.id && lastMessage) {
            lastMessage.deepSearchId = savedResult.id;
          }
        }
      } catch (error) {
        console.error("保存深度检索结果失败:", error);
        // 保存失败不影响正常流程
      }
    } catch (error) {
      // 重置所有处理状态
      processingStatus.value.isPlanGenerating = false;
      processingStatus.value.isResearchInProgress = false;
      processingStatus.value.isReportGenerating = false;
      processingStatus.value.isResearchCompleted = false;
      streaming.value = false;
      aiThinking.value = false;
      aiTyping.value = false;
      throw error;
    }
  }

  return {
    // State
    connected,
    connecting,
    connectionError,
    currentThreadId,
    messages,
    streaming,
    streamingError,
    config,
    ragResources,
    currentStream,
    aiThinking,
    aiTyping,
    toolCalling,
    currentToolCalls,
    interruptPending,
    interruptOptions,
    threadInterruptedMap,
    setThreadInterrupted,
    getThreadInterrupted,
    processingStatus,
    currentRunningTaskId,

    // Actions
    initDeerFlow,
    fetchRAGResources,
    sendMessage,
    startStreaming,
    stopStreaming,
    clearMessages,
    setThreadId,
    setCurrentRunningTaskId,
    toggleThoughtExpanded,
    sendInterruptResponse,
    loadHistoryTask,
    replayHistoryTask,
    loadChatHistory,
  };
});