"use client";

import { useCallback, useEffect, useRef, useState } from "react";

import { abortAgentChat, forkAgentChat, rejectAgentQuestion, replyAgentPermission, replyAgentQuestion, resumeAgentChatStream, streamAgentChat } from "@/lib/chatStream";
import type { PermissionReply, StreamEvent } from "@/lib/chatStream";
import type { AgentArtifact, ChatSessionSummary, LoadedChatState, Message } from "../GlobalChatbox.types";
import { cloneMessages } from "../GlobalChatbox.utils";
import { createEmptyChatState, deleteChatSession, listChatSessions, loadChatSessionById, saveActiveChatState, updateChatSessionTitle } from "../chatStorage";
import { applyQuestionResponse, cancelRunningTodos, completeRunningProgress, createAssistantMessage, createPersistedStateKey, createTodoUpdateFromEvent, createUserMessage, dedupeQuestionsAcrossMessages, finalizeAssistantMessageAfterAbort, normalizeSessionTodos, toPermissionStatus, upsertPermission, upsertProgress, upsertQuestionAcrossMessages } from "./agentChatSessionState";
import type { PromptRunOptions, UseAgentChatSessionOptions } from "./useAgentChatSession.types";

export const useAgentChatSession = ({
  projectId,
  onToolCall,
  onBeforeSend,
  getModel,
  getApprovalMode,
}: UseAgentChatSessionOptions) => {
  const hydrationCompletedRef = useRef(false);
  const hydrationNonceRef = useRef(0);

  const [messages, setMessages] = useState<Message[]>([]);
  const [sessionTitle, setSessionTitle] = useState<string | undefined>(undefined);
  const [isSessionTitleManuallyEdited, setIsSessionTitleManuallyEdited] = useState(false);
  const [sessionId, setSessionId] = useState<string | undefined>(undefined);
  const [chatSessions, setChatSessions] = useState<ChatSessionSummary[]>([]);
  const [isStreaming, setIsStreaming] = useState(false);
  const [isHydrating, setIsHydrating] = useState(true);
  const abortRef = useRef<AbortController | null>(null);
  const sessionIdRef = useRef<string | undefined>(undefined);
  const messagesRef = useRef<Message[]>([]);
  const resumeStreamingSessionRef = useRef<((sessionId: string) => void) | null>(null);
  const isSessionTitleManuallyEditedRef = useRef(false);
  const cancelPromiseRef = useRef<Promise<void> | null>(null);
  const titleUpdateNonceRef = useRef(0);
  const lastPersistedStateKeyRef = useRef(
    createPersistedStateKey({
      sessionId: undefined,
      title: undefined,
      isTitleManuallyEdited: false,
      messages: [],
    }),
  );

  useEffect(() => {
    sessionIdRef.current = sessionId;
  }, [sessionId]);

  useEffect(() => {
    messagesRef.current = messages;
  }, [messages]);


  useEffect(() => {
    isSessionTitleManuallyEditedRef.current = isSessionTitleManuallyEdited;
  }, [isSessionTitleManuallyEdited]);

  useEffect(() => {
    let cancelled = false;

    const hydrate = async () => {
      setIsHydrating(true);
      hydrationCompletedRef.current = false;

      if (!projectId) {
        sessionIdRef.current = undefined;
        lastPersistedStateKeyRef.current = createPersistedStateKey({
          title: undefined,
          isTitleManuallyEdited: false,
          messages: [],
          sessionId: undefined,
        });
        hydrationCompletedRef.current = true;
        hydrationNonceRef.current += 1;
        titleUpdateNonceRef.current += 1;
        setMessages([]);
        setSessionTitle(undefined);
        setIsSessionTitleManuallyEdited(false);
        setSessionId(undefined);
        setChatSessions([]);
        setIsHydrating(false);
        return;
      }

      try {
        const sessions = await listChatSessions();
        const streamingSession = sessions.find((session) => session.isStreaming);
        const loadedState = streamingSession
          ? await loadChatSessionById(streamingSession.id)
          : createEmptyChatState();
        if (cancelled) return;

        sessionIdRef.current = loadedState.sessionId;
        lastPersistedStateKeyRef.current = createPersistedStateKey(loadedState);
        hydrationCompletedRef.current = true;
        hydrationNonceRef.current += 1;
        titleUpdateNonceRef.current += 1;

        setMessages(
          normalizeSessionTodos(dedupeQuestionsAcrossMessages(loadedState.messages)),
        );
        setSessionTitle(loadedState.title);
        setIsSessionTitleManuallyEdited(loadedState.isTitleManuallyEdited ?? false);
        setSessionId(loadedState.sessionId);
        setChatSessions(sessions);
        if (
          loadedState.sessionId &&
          (loadedState.isStreaming || streamingSession?.isStreaming)
        ) {
          resumeStreamingSessionRef.current?.(loadedState.sessionId);
        }
      } catch (error) {
        console.error("[GlobalChatbox] Failed to hydrate chat state:", error);
      } finally {
        if (!cancelled) {
          setIsHydrating(false);
        }
      }
    };

    void hydrate();

    return () => {
      cancelled = true;
    };
  }, [projectId]);

  useEffect(() => {
    if (!projectId || isHydrating || !hydrationCompletedRef.current) return;

    const currentHydrationNonce = hydrationNonceRef.current;
    const persistTimer = window.setTimeout(() => {
      if (isStreaming) {
        return;
      }

      const state: LoadedChatState = {
        title: sessionTitle,
        isTitleManuallyEdited: isSessionTitleManuallyEdited,
        messages,
        sessionId,
      };

      const currentStateKey = createPersistedStateKey(state);
      if (currentStateKey === lastPersistedStateKeyRef.current) {
        return;
      }

      void saveActiveChatState(state)
        .then((sessionId) => {
          if (hydrationNonceRef.current !== currentHydrationNonce) return;
          sessionIdRef.current = sessionId;
          lastPersistedStateKeyRef.current = createPersistedStateKey({
            ...state,
            sessionId,
          });
          return listChatSessions();
        })
        .then((sessions) => {
          if (!sessions || hydrationNonceRef.current !== currentHydrationNonce) return;
          setChatSessions(sessions);
        })
        .catch((error) => {
          console.error("[GlobalChatbox] Failed to persist chat state:", error);
        });
    }, 150);

    return () => {
      window.clearTimeout(persistTimer);
    };
  }, [isHydrating, isSessionTitleManuallyEdited, isStreaming, messages, projectId, sessionId, sessionTitle]);

  const appendArtifact = useCallback((messageId: string, artifact: AgentArtifact) => {
    setMessages((prev) =>
      prev.map((message) =>
        message.id === messageId
          ? {
              ...message,
              artifacts: [...(message.artifacts ?? []), artifact],
            }
          : message,
      ),
    );
  }, []);

  const getLastAssistantMessageId = useCallback((fallback?: string) => {
    const assistant = [...messagesRef.current]
      .reverse()
      .find((message) => message.role === "assistant");
    return assistant?.id ?? fallback;
  }, []);

  const applyStreamEvent = useCallback(
    (
      event: StreamEvent,
      options?: {
        assistantMessageId?: string;
      },
    ) => {
      if (
        event.type !== "session_title" &&
        "sessionId" in event &&
        event.sessionId &&
        event.sessionId !== sessionIdRef.current
      ) {
        sessionIdRef.current = event.sessionId;
        setSessionId(event.sessionId);
      }

      if (event.type === "state") {
        const nextMessages = normalizeSessionTodos(
          dedupeQuestionsAcrossMessages(cloneMessages(event.messages as Message[])),
        );
        messagesRef.current = nextMessages;
        setMessages(nextMessages);
        setIsStreaming(event.isStreaming);
        return;
      }

      if (event.type === "session_title") {
        const nextTitle = event.title.trim();
        if (nextTitle && !isSessionTitleManuallyEditedRef.current) {
          const currentSessionId = sessionIdRef.current;
          const targetSessionId = event.sessionId || currentSessionId;
          if (targetSessionId === currentSessionId) {
            setSessionTitle(nextTitle);
            lastPersistedStateKeyRef.current = createPersistedStateKey({
              sessionId: targetSessionId,
              title: nextTitle,
              isTitleManuallyEdited: false,
              messages: messagesRef.current,
            });
          }
          if (targetSessionId) {
            const currentNonce = ++titleUpdateNonceRef.current;
            void updateChatSessionTitle(targetSessionId, nextTitle, {
              isTitleManuallyEdited: false,
            })
              .then(() => listChatSessions())
              .then((sessions) => {
                if (titleUpdateNonceRef.current !== currentNonce) return;
                setChatSessions(sessions);
              })
              .catch((error) => {
                console.error("[GlobalChatbox] Failed to persist session title:", error);
              });
          }
        }
        return;
      }

      const assistantMessageId = getLastAssistantMessageId(options?.assistantMessageId);
      if (!assistantMessageId) {
        return;
      }

      if (event.type === "token") {
        setMessages((prev) =>
          prev.map((message) =>
            message.id === assistantMessageId
              ? {
                  ...message,
                  content: message.content + event.content,
                  isError: false,
                }
              : message,
          ),
        );
      } else if (event.type === "progress") {
        setMessages((prev) =>
          prev.map((message) =>
            message.id === assistantMessageId
              ? { ...message, progress: upsertProgress(message.progress, event) }
              : message,
          ),
        );
      } else if (event.type === "tool_call") {
        onToolCall(event, {
          assistantMessageId,
          appendArtifact,
        });
      } else if (event.type === "permission_request") {
        setMessages((prev) =>
          prev.map((message) =>
            message.id === assistantMessageId
              ? {
                  ...message,
                  permissions: upsertPermission(message.permissions, event),
                }
              : message,
          ),
        );
      } else if (event.type === "permission_response") {
        setMessages((prev) =>
          prev.map((message) => {
            if (message.id !== assistantMessageId || !message.permissions?.length) {
              return message;
            }
            return {
              ...message,
              permissions: message.permissions.map((permission) =>
                permission.requestId === event.requestId
                  ? {
                      ...permission,
                      status: toPermissionStatus(event.reply),
                      repliedAt: Date.now(),
                      error: undefined,
                    }
                  : permission,
              ),
            };
          }),
        );
      } else if (event.type === "question_request") {
        setMessages((prev) =>
          upsertQuestionAcrossMessages(prev, event, assistantMessageId),
        );
      } else if (event.type === "question_response") {
        setMessages((prev) =>
          prev.map((message) =>
            message.questions?.some((question) => question.requestId === event.requestId)
              ? {
                  ...message,
                  questions: applyQuestionResponse(message.questions, event),
                }
              : message,
          ),
        );
      } else if (event.type === "todo_update") {
        setMessages((prev) =>
          normalizeSessionTodos(
            prev,
            createTodoUpdateFromEvent(event),
            assistantMessageId,
          ),
        );
      } else if (event.type === "done") {
        setMessages((prev) =>
          prev.map((message) => {
            if (message.id !== assistantMessageId) return message;
            const completedProgress = completeRunningProgress(message.progress);
            if (
              message.content.trim().length === 0 &&
              !(message.artifacts?.length)
            ) {
              return {
                ...message,
                content:
                  "Agent 已完成处理，但没有生成文本回答。请查看过程记录，或换个更具体的问题重试。",
                progress: completedProgress,
              };
            }
            return { ...message, progress: completedProgress };
          }),
        );
        setIsStreaming(false);
      } else if (event.type === "error") {
        setMessages((prev) =>
          prev.map((message) =>
            message.id === assistantMessageId
              ? {
                  ...message,
                  content: message.content || `⚠️ **错误：** ${event.message}`,
                  isError: true,
                  progress: completeRunningProgress(message.progress),
                  todos: cancelRunningTodos(message.todos),
                }
              : message,
          ),
        );
        setIsStreaming(false);
      }
    },
    [appendArtifact, getLastAssistantMessageId, onToolCall],
  );

  const resumeStreamingSession = useCallback(
    (nextSessionId: string) => {
      const controller = new AbortController();
      abortRef.current?.abort();
      abortRef.current = controller;
      setIsStreaming(true);

      void resumeAgentChatStream({
        sessionId: nextSessionId,
        signal: controller.signal,
        onEvent: (event) => applyStreamEvent(event),
      })
        .catch((error) => {
          if (!controller.signal.aborted) {
            console.error("[GlobalChatbox] Failed to resume chat stream:", error);
            setIsStreaming(false);
          }
        })
        .finally(() => {
          if (abortRef.current === controller) {
            abortRef.current = null;
          }
        });
    },
    [applyStreamEvent],
  );
  resumeStreamingSessionRef.current = resumeStreamingSession;

  const runPrompt = useCallback(
    async ({
      prompt: rawPrompt,
      sessionIdOverride,
      preparedMessages,
      userMessage,
      assistantMessage,
    }: PromptRunOptions) => {
      const prompt = rawPrompt.trim();
      if (!prompt || isStreaming || isHydrating) return;

      await cancelPromiseRef.current?.catch(() => undefined);
      onBeforeSend?.();

      const nextUserMessage = userMessage ?? createUserMessage(prompt);
      const nextAssistantMessage = assistantMessage ?? createAssistantMessage();
      const nextMessages =
        preparedMessages ??
        [...messages, nextUserMessage, nextAssistantMessage];

      const clonedNextMessages = cloneMessages(nextMessages);
      setIsStreaming(true);
      messagesRef.current = clonedNextMessages;
      setMessages(clonedNextMessages);
      if (sessionIdOverride !== undefined) {
        sessionIdRef.current = sessionIdOverride;
        setSessionId(sessionIdOverride);
      }

      const controller = new AbortController();
      abortRef.current = controller;

      try {
        await streamAgentChat({
          message: prompt,
          sessionId: sessionIdOverride ?? sessionIdRef.current,
          model: getModel?.(),
          approvalMode: getApprovalMode?.(),
          signal: controller.signal,
          onEvent: (event) =>
            applyStreamEvent(event, {
              assistantMessageId: nextAssistantMessage.id,
            }),
        });
      } catch (error) {
        if (controller.signal.aborted) {
          setMessages((prev) =>
            prev
              .map((message) =>
                message.id === nextAssistantMessage.id
                  ? finalizeAssistantMessageAfterAbort(message)
                  : message,
              )
              .filter(
                (message) =>
                  !(
                    message.id === nextAssistantMessage.id &&
                    message.role === "assistant" &&
                    message.content.trim().length === 0 &&
                    !(message.artifacts?.length) &&
                    !(message.progress?.length) &&
                    !message.todos
                  ),
              ),
          );
          return;
        }
        setMessages((prev) =>
          prev.map((message) =>
            message.id === nextAssistantMessage.id
              ? {
                  ...message,
                  content: `⚠️ **错误：** ${String(error)}`,
                  isError: true,
                  progress: completeRunningProgress(message.progress),
                }
              : message,
          ),
        );
        setIsStreaming(false);
      } finally {
        abortRef.current = null;
        setIsStreaming(false);
      }
    },
    [
      applyStreamEvent,
      getApprovalMode,
      getModel,
      isHydrating,
      isStreaming,
      messages,
      onBeforeSend,
    ],
  );

  const abort = useCallback(() => {
    const controller = abortRef.current;
    controller?.abort();
    setIsStreaming(false);
    const assistantMessageId = getLastAssistantMessageId();

    if (assistantMessageId) {
      setMessages((prev) =>
        prev.map((message) =>
          message.id === assistantMessageId
            ? finalizeAssistantMessageAfterAbort(message)
            : message,
        ),
      );
    }

    const cancelPromise = abortAgentChat(sessionIdRef.current).catch((error) => {
      console.error("[GlobalChatbox] Failed to abort agent session:", error);
    });
    const trackedCancelPromise = cancelPromise.finally(() => {
      if (cancelPromiseRef.current === trackedCancelPromise) {
        cancelPromiseRef.current = null;
      }
    });
    cancelPromiseRef.current = trackedCancelPromise;
  }, [getLastAssistantMessageId]);

  const replyPermission = useCallback(
    async (requestId: string, reply: PermissionReply) => {
      const target = messagesRef.current
        .flatMap((message) => message.permissions ?? [])
        .find((permission) => permission.requestId === requestId);
      if (!target || target.status === "submitting") {
        return;
      }

      setMessages((prev) =>
        prev.map((message) =>
          !message.permissions?.some((permission) => permission.requestId === requestId)
            ? message
            : {
                ...message,
                permissions: message.permissions.map((permission) =>
                  permission.requestId === requestId
                    ? { ...permission, status: "submitting", error: undefined }
                    : permission,
                ),
              },
        ),
      );

      try {
        await replyAgentPermission(target.sessionId, requestId, reply);
        setMessages((prev) =>
          prev.map((message) =>
            !message.permissions?.some((permission) => permission.requestId === requestId)
              ? message
              : {
                  ...message,
                  permissions: message.permissions.map((permission) =>
                    permission.requestId === requestId
                      ? {
                          ...permission,
                          status: toPermissionStatus(reply),
                          repliedAt: Date.now(),
                          error: undefined,
                        }
                      : permission,
                  ),
                },
          ),
        );
      } catch (error) {
        setMessages((prev) =>
          prev.map((message) =>
            !message.permissions?.some((permission) => permission.requestId === requestId)
              ? message
              : {
                  ...message,
                  permissions: message.permissions.map((permission) =>
                    permission.requestId === requestId
                      ? {
                          ...permission,
                          status: "error",
                          error: error instanceof Error ? error.message : String(error),
                        }
                      : permission,
                  ),
                },
          ),
        );
      }
    },
    [],
  );

  const replyQuestion = useCallback(
    async (requestId: string, answers: string[][]) => {
      const target = messagesRef.current
        .flatMap((message) => message.questions ?? [])
        .find((question) => question.requestId === requestId);
      if (!target || target.status === "submitting") {
        return;
      }

      setMessages((prev) =>
        prev.map((message) =>
          !message.questions?.some((question) => question.requestId === requestId)
            ? message
            : {
                ...message,
                questions: message.questions.map((question) =>
                  question.requestId === requestId
                    ? { ...question, status: "submitting", error: undefined }
                    : question,
                ),
              },
        ),
      );

      try {
        await replyAgentQuestion(target.sessionId, requestId, answers);
        setMessages((prev) =>
          prev.map((message) =>
            !message.questions?.some((question) => question.requestId === requestId)
              ? message
              : {
                  ...message,
                  questions: message.questions.map((question) =>
                    question.requestId === requestId
                      ? {
                          ...question,
                          status: "answered",
                          answers,
                          repliedAt: Date.now(),
                          error: undefined,
                        }
                      : question,
                  ),
                },
          ),
        );
      } catch (error) {
        setMessages((prev) =>
          prev.map((message) =>
            !message.questions?.some((question) => question.requestId === requestId)
              ? message
              : {
                  ...message,
                  questions: message.questions.map((question) =>
                    question.requestId === requestId
                      ? {
                          ...question,
                          status: "error",
                          error: error instanceof Error ? error.message : String(error),
                        }
                      : question,
                  ),
                },
          ),
        );
      }
    },
    [],
  );

  const rejectQuestion = useCallback(
    async (requestId: string) => {
      const target = messagesRef.current
        .flatMap((message) => message.questions ?? [])
        .find((question) => question.requestId === requestId);
      if (!target || target.status === "submitting") {
        return;
      }

      setMessages((prev) =>
        prev.map((message) =>
          !message.questions?.some((question) => question.requestId === requestId)
            ? message
            : {
                ...message,
                questions: message.questions.map((question) =>
                  question.requestId === requestId
                    ? { ...question, status: "submitting", error: undefined }
                    : question,
                ),
              },
        ),
      );

      try {
        await rejectAgentQuestion(target.sessionId, requestId);
        setMessages((prev) =>
          prev.map((message) =>
            !message.questions?.some((question) => question.requestId === requestId)
              ? message
              : {
                  ...message,
                  questions: message.questions.map((question) =>
                    question.requestId === requestId
                      ? {
                          ...question,
                          status: "rejected",
                          repliedAt: Date.now(),
                          error: undefined,
                        }
                      : question,
                  ),
                },
          ),
        );
      } catch (error) {
        setMessages((prev) =>
          prev.map((message) =>
            !message.questions?.some((question) => question.requestId === requestId)
              ? message
              : {
                  ...message,
                  questions: message.questions.map((question) =>
                    question.requestId === requestId
                      ? {
                          ...question,
                          status: "error",
                          error: error instanceof Error ? error.message : String(error),
                        }
                      : question,
                  ),
                },
          ),
        );
      }
    },
    [],
  );

  const createSession = useCallback(() => {
    if (isHydrating || isStreaming) return;

    const controller = abortRef.current;
    controller?.abort();
    hydrationNonceRef.current += 1;
    titleUpdateNonceRef.current += 1;
    sessionIdRef.current = undefined;
    lastPersistedStateKeyRef.current = createPersistedStateKey({
      title: "新对话",
      isTitleManuallyEdited: false,
      messages: [],
      sessionId: undefined,
    });
    setMessages([]);
    setSessionTitle("新对话");
    setIsSessionTitleManuallyEdited(false);
    setSessionId(undefined);
    setIsStreaming(false);
  }, [isHydrating, isStreaming]);

  const switchSession = useCallback(
    async (nextSessionId: string) => {
      if (isHydrating || isStreaming || sessionIdRef.current === nextSessionId) {
        return;
      }

      setIsHydrating(true);
      try {
        const [nextState, sessions] = await Promise.all([
          loadChatSessionById(nextSessionId),
          listChatSessions(),
        ]);

        hydrationNonceRef.current += 1;
        titleUpdateNonceRef.current += 1;
        sessionIdRef.current = nextState.sessionId;
        lastPersistedStateKeyRef.current = createPersistedStateKey(nextState);
        setMessages(nextState.messages);
        setSessionTitle(nextState.title);
        setIsSessionTitleManuallyEdited(nextState.isTitleManuallyEdited ?? false);
        setSessionId(nextState.sessionId);
        setChatSessions(sessions);
        if (nextState.sessionId && nextState.isStreaming) {
          resumeStreamingSession(nextState.sessionId);
        } else {
          setIsStreaming(false);
        }
      } catch (error) {
        console.error("[GlobalChatbox] Failed to switch chat session:", error);
      } finally {
        setIsHydrating(false);
      }
    },
    [isHydrating, isStreaming, resumeStreamingSession],
  );

  const removeSession = useCallback(
    async (targetSessionId: string) => {
      if (isHydrating || isStreaming) return;

      setChatSessions((prev) =>
        prev.filter((session) => session.id !== targetSessionId),
      );

      try {
        const nextActiveSessionId = await deleteChatSession(
          targetSessionId,
        );
        const sessions = await listChatSessions();
        setChatSessions(sessions);

        if (sessionIdRef.current !== targetSessionId) {
          return;
        }

        if (!nextActiveSessionId) {
          hydrationNonceRef.current += 1;
          titleUpdateNonceRef.current += 1;
          sessionIdRef.current = undefined;
          lastPersistedStateKeyRef.current = createPersistedStateKey({
            title: undefined,
            isTitleManuallyEdited: false,
            messages: [],
            sessionId: undefined,
          });
          setMessages([]);
          setSessionTitle(undefined);
          setIsSessionTitleManuallyEdited(false);
          setSessionId(undefined);
          return;
        }

        setIsHydrating(true);
        const [nextState, sessionsAfterDelete] = await Promise.all([
          loadChatSessionById(nextActiveSessionId),
          listChatSessions(),
        ]);
        hydrationNonceRef.current += 1;
        titleUpdateNonceRef.current += 1;
        sessionIdRef.current = nextState.sessionId;
        lastPersistedStateKeyRef.current = createPersistedStateKey(nextState);
        setMessages(nextState.messages);
        setSessionTitle(nextState.title);
        setIsSessionTitleManuallyEdited(nextState.isTitleManuallyEdited ?? false);
        setSessionId(nextState.sessionId);
        setChatSessions(sessionsAfterDelete);
      } catch (error) {
        console.error("[GlobalChatbox] Failed to delete chat session:", error);
        try {
          setChatSessions(await listChatSessions());
        } catch (refreshError) {
          console.error("[GlobalChatbox] Failed to refresh chat sessions:", refreshError);
        }
      } finally {
        setIsHydrating(false);
      }
    },
    [isHydrating, isStreaming],
  );

  const sendPrompt = useCallback(
    async (rawPrompt: string) => {
      await runPrompt({ prompt: rawPrompt });
    },
    [runPrompt],
  );

  const renameSession = useCallback(
    async (targetSessionId: string, nextTitle: string) => {
      const normalizedTitle = nextTitle.trim();
      if (!normalizedTitle || isHydrating) return;

      try {
        await updateChatSessionTitle(targetSessionId, normalizedTitle, {
          isTitleManuallyEdited: true,
        });
        const sessions = await listChatSessions();
        setChatSessions(sessions);

        if (sessionIdRef.current === targetSessionId) {
          setSessionTitle(normalizedTitle);
          setIsSessionTitleManuallyEdited(true);
          lastPersistedStateKeyRef.current = createPersistedStateKey({
            sessionId: targetSessionId,
            title: normalizedTitle,
            isTitleManuallyEdited: true,
            messages,
          });
        }
      } catch (error) {
        console.error("[GlobalChatbox] Failed to rename chat session:", error);
      }
    },
    [isHydrating, messages],
  );

  const createBranch = useCallback(
    async (messageId: string) => {
      if (isHydrating || isStreaming) return;

      const assistantIndex = messages.findIndex(
        (message) => message.id === messageId && message.role === "assistant",
      );
      if (assistantIndex < 0) return;

      const currentSessionId = sessionIdRef.current;
      const keepMessageCount = assistantIndex + 1;
      const copiedMessages = cloneMessages(messages.slice(0, keepMessageCount));
      const forkedSessionId = await forkAgentChat(currentSessionId, keepMessageCount);

      sessionIdRef.current = forkedSessionId;
      setSessionId(forkedSessionId);
      messagesRef.current = copiedMessages;
      setMessages(copiedMessages);
      setIsSessionTitleManuallyEdited(false);
      const forkTitle = sessionTitle ? `${sessionTitle} 副本` : "新对话副本";
      setSessionTitle(forkTitle);
      try {
        await saveActiveChatState({
          title: forkTitle,
          isTitleManuallyEdited: false,
          messages: copiedMessages,
          sessionId: forkedSessionId,
        });
        setChatSessions(await listChatSessions());
      } catch (error) {
        console.error("[GlobalChatbox] Failed to refresh chat sessions after fork:", error);
      }
    },
    [isHydrating, isStreaming, messages, sessionTitle],
  );

  return {
    messages,
    chatSessions,
    activeSessionId: sessionIdRef.current,
    isHydrating,
    isStreaming,
    sessionTitle,
    sessionId,
    sendPrompt,
    createBranch,
    abort,
    replyPermission,
    replyQuestion,
    rejectQuestion,
    createSession,
    renameSession,
    removeSession,
    switchSession,
  };
};