// @ts-nocheck
import { debugLog } from './common';

/**
 * 任务轮询事件处理器
 * 将从 REST API 轮询获取的事件转换为前端状态更新
 */
export const taskPollingMethods = {
    /**
     * 处理任务事件（从轮询获取）
     */
    handleTaskEvent(event: any) {
        if (!event || !event.type) {
            return;
        }

        const eventType = event.type;
        const eventData = event.data || {};
        const eventIdx = event.idx;

        // 事件去重检查
        if (typeof eventIdx === 'number') {
            if (!this._processedEventIndices) {
                this._processedEventIndices = new Set();
            }

            if (this._processedEventIndices.has(eventIdx)) {
                debugLog(`[TaskPolling] 跳过重复事件 #${eventIdx}`);
                return;
            }

            this._processedEventIndices.add(eventIdx);

            // 限制 Set 大小（保留最近 1000 个）
            if (this._processedEventIndices.size > 1000) {
                const firstIdx = Math.min(...this._processedEventIndices);
                this._processedEventIndices.delete(firstIdx);
            }
        }

        // 检查事件的 conversation_id 是否匹配当前对话
        // 如果不匹配，忽略该事件（避免切换对话后旧任务的事件显示到新对话中）
        if (eventData.conversation_id && this.currentConversationId) {
            if (eventData.conversation_id !== this.currentConversationId) {
                console.log(`[DEBUG_AWAITING] 忽略不匹配的事件`, {
                    eventType,
                    eventIdx,
                    eventConversationId: eventData.conversation_id,
                    currentConversationId: this.currentConversationId
                });
                debugLog(`[TaskPolling] 忽略不匹配的事件 #${eventIdx}: ${eventType}, 事件对话=${eventData.conversation_id}, 当前对话=${this.currentConversationId}`);
                return;
            }
        }

        debugLog(`[TaskPolling] 处理事件 #${eventIdx}: ${eventType}`, eventData);

        console.log(`[DEBUG_AWAITING] 处理事件`, {
            eventType,
            eventIdx,
            eventConversationId: eventData.conversation_id,
            currentConversationId: this.currentConversationId
        });

        // 根据事件类型调用对应的处理方法
        switch (eventType) {
            case 'ai_message_start':
                this.handleAiMessageStart(eventData, eventIdx);
                break;

            case 'thinking_start':
                this.handleThinkingStart(eventData, eventIdx);
                break;

            case 'thinking_chunk':
                this.handleThinkingChunk(eventData, eventIdx);
                break;

            case 'thinking_end':
                this.handleThinkingEnd(eventData, eventIdx);
                break;

            case 'text_start':
                this.handleTextStart(eventData, eventIdx);
                break;

            case 'text_chunk':
                this.handleTextChunk(eventData, eventIdx);
                break;

            case 'text_end':
                this.handleTextEnd(eventData, eventIdx);
                break;

            case 'tool_preparing':
                this.handleToolPreparing(eventData, eventIdx);
                break;

            case 'tool_start':
                this.handleToolStart(eventData, eventIdx);
                break;

            case 'tool_intent':
                this.handleToolIntent(eventData, eventIdx);
                break;

            case 'tool_update_action':
            case 'update_action':
                this.handleToolUpdateAction(eventData, eventIdx);
                break;

            case 'append_payload':
                this.handleAppendPayload(eventData, eventIdx);
                break;

            case 'modify_payload':
                this.handleModifyPayload(eventData, eventIdx);
                break;

            case 'task_complete':
                this.handleTaskComplete(eventData, eventIdx);
                break;

            case 'task_stopped':
                this.handleTaskStopped(eventData, eventIdx);
                break;

            case 'error':
                this.handleTaskError(eventData, eventIdx);
                break;

            case 'token_update':
                this.handleTokenUpdate(eventData, eventIdx);
                break;

            case 'conversation_changed':
                this.handleConversationChanged(eventData, eventIdx);
                break;

            case 'conversation_resolved':
                this.handleConversationResolved(eventData, eventIdx);
                break;

            case 'user_message':
                this.handleUserMessage(eventData, eventIdx);
                break;

            default:
                debugLog(`[TaskPolling] 未知事件类型: ${eventType}`);
        }

        // 注意：不要在这里清除 _rebuildingFromScratch 标记
        // 该标记应该在恢复完所有历史事件后才清除
    },

    handleAiMessageStart(data: any, eventIdx: number) {
        const lastMessage = this.messages[this.messages.length - 1];
        console.log('[DEBUG_AWAITING] ===== handleAiMessageStart =====', {
            eventIdx,
            lastMessageRole: lastMessage?.role,
            lastMessageAwaitingFirstContent: lastMessage?.awaitingFirstContent,
            lastMessageGeneratingLabel: lastMessage?.generatingLabel
        });

        debugLog('[TaskPolling] AI消息开始, idx:', eventIdx);
        console.log('[AiMessageStart] 开始处理', {
            eventIdx,
            messagesLength: this.messages.length,
            lastMessageRole: this.messages[this.messages.length - 1]?.role,
            streamingMessage: this.streamingMessage,
            taskInProgress: this.taskInProgress,
            currentConversationId: this.currentConversationId
        });

        if (this.waitingForSubAgent) {
            this.waitingForSubAgent = false;
        }

        // 检查是否已经有 assistant 消息
        const hasAssistantMessage = lastMessage && lastMessage.role === 'assistant';

        console.log('[AiMessageStart] 最后一条消息状态', {
            hasAssistantMessage,
            lastMessageActionsLength: lastMessage?.actions?.length || 0,
            lastMessageAwaitingFirstContent: lastMessage?.awaitingFirstContent,
            lastMessageGeneratingLabel: lastMessage?.generatingLabel
        });

        // 判断是否是刷新恢复的情况：
        // 1. 有assistant消息
        // 2. 且该消息正在streaming或者没有任何内容（说明是刚创建的）
        // 3. 且不是历史加载完成的消息（历史消息的awaitingFirstContent应该是false）
        const isRefreshRestore = hasAssistantMessage &&
            (this.streamingMessage || !lastMessage.actions || lastMessage.actions.length === 0) &&
            (lastMessage.awaitingFirstContent === true || this.taskInProgress);

        console.log('[AiMessageStart] 场景判断', {
            isRefreshRestore,
            streamingMessage: this.streamingMessage,
            hasActions: !!(lastMessage?.actions && lastMessage.actions.length > 0),
            awaitingFirstContent: lastMessage?.awaitingFirstContent,
            taskInProgress: this.taskInProgress
        });

        if (isRefreshRestore) {
            console.log('[AiMessageStart] 场景=刷新恢复，复用现有assistant消息');
            debugLog('[TaskPolling] 刷新恢复场景，复用现有 assistant 消息');
            // 只更新状态，不创建新消息
            this.taskInProgress = true;
            this.stopRequested = false;
            this.streamingMessage = true;

            // 确保 awaitingFirstContent 被正确设置
            const hasContent = lastMessage.actions && lastMessage.actions.length > 0;
            if (!hasContent) {
                lastMessage.awaitingFirstContent = true;
                lastMessage.generatingLabel = lastMessage.generatingLabel || '思考中...';
                console.log('[AiMessageStart] 设置等待动画', {
                    awaitingFirstContent: true,
                    generatingLabel: lastMessage.generatingLabel
                });
            } else {
                // 如果已有内容，确保等待动画不显示
                lastMessage.awaitingFirstContent = false;
                lastMessage.generatingLabel = '';
                console.log('[AiMessageStart] 关闭等待动画（已有内容）');
            }
            return;
        }

        // 其他情况：创建新的 assistant 消息
        console.log('[AiMessageStart] 场景=创建新消息');
        debugLog('[TaskPolling] 创建新的 assistant 消息');
        this.monitorResetSpeech();
        this.cleanupStaleToolActions();
        this.taskInProgress = true;
        this.chatStartAssistantMessage();
        this.stopRequested = false;
        this.streamingMessage = true;

        const newMessage = this.messages[this.messages.length - 1];
        console.log('[AiMessageStart] 新消息创建完成', {
            role: newMessage?.role,
            awaitingFirstContent: newMessage?.awaitingFirstContent,
            generatingLabel: newMessage?.generatingLabel,
            actionsLength: newMessage?.actions?.length || 0,
            messagesLength: this.messages.length
        });

        // 如果是从头重建，标记消息为静默恢复
        if (this._rebuildingFromScratch) {
            if (newMessage && newMessage.role === 'assistant') {
                debugLog('[TaskPolling] 标记消息为静默恢复（从头重建）');
                newMessage.awaitingFirstContent = false;
                newMessage.generatingLabel = '';
                console.log('[AiMessageStart] 从头重建，关闭等待动画');
            }
        }

        // 强制触发Vue响应式更新
        this.$forceUpdate();
        console.log('[AiMessageStart] 已调用$forceUpdate');

        this.$nextTick(() => {
            console.log('[AiMessageStart] nextTick回调执行');
            this.scrollToBottom();
        });
    },

    handleThinkingStart(data: any, eventIdx: number) {
        console.log('[ThinkingStart] 开始处理', { eventIdx });
        debugLog('[TaskPolling] 思考开始, idx:', eventIdx);
        const ignoreThinking = this.runMode === 'fast' || this.thinkingMode === false;
        if (ignoreThinking) {
            this.monitorEndModelOutput();
            console.log('[ThinkingStart] 忽略思考（fast模式或关闭思考）');
            return;
        }

        // 防御性检查：如果没有assistant消息，先创建一个
        const lastMessage = this.messages[this.messages.length - 1];
        if (!lastMessage || lastMessage.role !== 'assistant') {
            console.log('[DEBUG_AWAITING] ThinkingStart 检测到缺少assistant消息，自动创建');
            this.chatStartAssistantMessage();
        }

        this.monitorShowThinking();

        const result = this.chatStartThinkingAction();

        if (result && result.blockId) {
            const blockId = result.blockId;

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

            // 有内容了，关闭等待动画
            if (lastMessage && lastMessage.role === 'assistant') {
                console.log('[ThinkingStart] 关闭等待动画', {
                    beforeAwaitingFirstContent: lastMessage.awaitingFirstContent,
                    beforeGeneratingLabel: lastMessage.generatingLabel
                });
                lastMessage.awaitingFirstContent = false;
                lastMessage.generatingLabel = '';
            }

            // 只在非历史恢复时展开思考块
            if (!this._rebuildingFromScratch) {
                this.chatExpandBlock(blockId);
            }

            this.scrollToBottom();
            this.chatSetThinkingLock(blockId, true);

            // 强制触发 actions 数组的响应式更新
            if (lastMessage && lastMessage.actions) {
                lastMessage.actions = [...lastMessage.actions];
            }

            this.$forceUpdate();
        }
    },

    handleThinkingChunk(data: any, eventIdx: number) {
        if (this.runMode === 'fast' || this.thinkingMode === false) {
            return;
        }
        const thinkingAction = this.chatAppendThinkingChunk(data.content);
        if (thinkingAction) {
            this.$forceUpdate();
            this.$nextTick(() => {
                if (thinkingAction && thinkingAction.blockId) {
                    this.scrollThinkingToBottom(thinkingAction.blockId);
                }
                this.conditionalScrollToBottom();
            });
        }
        this.monitorShowThinking();
    },

    handleThinkingEnd(data: any) {
        debugLog('[TaskPolling] 思考结束');
        if (this.runMode === 'fast' || this.thinkingMode === false) {
            return;
        }
        const blockId = this.chatCompleteThinkingAction(data.full_content);
        if (blockId) {
            // 解锁思考块
            this.chatSetThinkingLock(blockId, false);

            // 只在非历史恢复时延迟折叠思考块
            if (!this._rebuildingFromScratch) {
                // 延迟折叠思考块（给用户一点时间看到思考完成）
                setTimeout(() => {
                    this.chatCollapseBlock(blockId);
                    this.$forceUpdate();
                }, 1000);
            } else {
                // 历史恢复时立即折叠，不需要动画
                this.chatCollapseBlock(blockId);
            }

            this.$nextTick(() => this.scrollThinkingToBottom(blockId));
        }
        this.$forceUpdate();
        this.monitorEndModelOutput();
    },

    handleTextStart(data: any) {
        console.log('[TextStart] 开始处理');
        debugLog('[TaskPolling] 文本开始');

        // 防御性检查：如果没有assistant消息，先创建一个
        const lastMessage = this.messages[this.messages.length - 1];
        if (!lastMessage || lastMessage.role !== 'assistant') {
            console.log('[DEBUG_AWAITING] TextStart 检测到缺少assistant消息，自动创建');
            this.chatStartAssistantMessage();
        }

        this.chatStartTextAction();

        // 有内容了，关闭等待动画
        const currentMessage = this.messages[this.messages.length - 1];
        if (currentMessage && currentMessage.role === 'assistant') {
            console.log('[TextStart] 关闭等待动画', {
                beforeAwaitingFirstContent: currentMessage.awaitingFirstContent,
                beforeGeneratingLabel: currentMessage.generatingLabel
            });
            currentMessage.awaitingFirstContent = false;
            currentMessage.generatingLabel = '';
        }

        this.$forceUpdate();
    },

    handleTextChunk(data: any) {
        if (data && typeof data.content === 'string' && data.content.length) {
            this.chatAppendTextChunk(data.content);
            this.$forceUpdate();
            this.conditionalScrollToBottom();
            const speech = data.content.replace(/\r/g, '');
            if (speech) {
                this.monitorShowSpeech(speech);
            }
        }
    },

    handleTextEnd(data: any) {
        debugLog('[TaskPolling] 文本结束');
        const full = data?.full_content || '';
        this.chatCompleteTextAction(full);
        this.$forceUpdate();
        this.monitorEndModelOutput();
    },

    handleToolPreparing(data: any) {
        console.log('[ToolPreparing] 开始处理', { name: data.name, id: data.id });
        debugLog('[TaskPolling] 工具准备中:', data.name);

        if (this.dropToolEvents) {
            console.log('[ToolPreparing] dropToolEvents=true，跳过');
            return;
        }

        const msg = this.chatEnsureAssistantMessage();
        if (!msg) {
            console.log('[ToolPreparing] 无法获取assistant消息');
            return;
        }

        if (msg.awaitingFirstContent) {
            console.log('[ToolPreparing] 关闭等待动画', {
                beforeAwaitingFirstContent: msg.awaitingFirstContent,
                beforeGeneratingLabel: msg.generatingLabel
            });
            msg.awaitingFirstContent = false;
            msg.generatingLabel = '';
        }

        const action = {
            id: data.id,
            type: 'tool',
            tool: {
                id: data.id,
                name: data.name,
                arguments: {},
                argumentSnapshot: null,
                argumentLabel: '',
                status: 'preparing',
                result: null,
                message: data.message || `准备调用 ${data.name}...`,
                intent_full: data.intent || '',
                intent_rendered: data.intent || ''
            },
            timestamp: Date.now()
        };

        msg.actions.push(action);
        this.preparingTools.set(data.id, action);
        this.toolRegisterAction(action, data.id);
        this.toolTrackAction(data.name, action);

        this.$forceUpdate();
        this.conditionalScrollToBottom();

        if (this.monitorPreviewTool) {
            this.monitorPreviewTool(data);
        }
    },

    handleToolStart(data: any) {
        debugLog('[TaskPolling] 工具开始:', data.name);

        if (this.dropToolEvents) {
            return;
        }

        let action = null;
        if (data.preparing_id && this.preparingTools.has(data.preparing_id)) {
            action = this.preparingTools.get(data.preparing_id);
            this.preparingTools.delete(data.preparing_id);
        } else {
            action = this.toolFindAction(data.id, data.preparing_id, data.execution_id);
        }

        if (!action) {
            const msg = this.chatEnsureAssistantMessage();
            if (!msg) {
                return;
            }
            action = {
                id: data.id,
                type: 'tool',
                tool: {
                    id: data.id,
                    name: data.name,
                    arguments: {},
                    argumentSnapshot: null,
                    argumentLabel: '',
                    status: 'running',
                    result: null
                },
                timestamp: Date.now()
            };
            msg.actions.push(action);
        }

        action.tool.status = 'running';
        action.tool.arguments = data.arguments;
        action.tool.argumentSnapshot = this.cloneToolArguments(data.arguments);
        action.tool.argumentLabel = this.buildToolLabel(action.tool.argumentSnapshot);
        action.tool.message = null;
        action.tool.id = data.id;
        action.tool.executionId = data.id;

        this.toolRegisterAction(action, data.id);
        this.toolTrackAction(data.name, action);
        this.$forceUpdate();
        this.conditionalScrollToBottom();

        if (this.monitorQueueTool) {
            this.monitorQueueTool(data);
        }
    },

    handleToolIntent(data: any) {
        debugLog('[TaskPolling] 工具意图:', data.name, data.intent);

        if (this.dropToolEvents) {
            return;
        }

        // 查找对应的工具 action
        const action = this.toolFindAction(data.id, data.preparing_id, data.execution_id);

        if (action && action.tool) {
            const newIntent = data.intent || '';

            // 如果 intent 没有变化，跳过
            if (action.tool.intent_full === newIntent) {
                return;
            }

            // 停止之前的打字机效果
            if (action.tool._intentTyping) {
                action.tool._intentTyping = false;
                if (action.tool._intentTimer) {
                    clearTimeout(action.tool._intentTimer);
                    action.tool._intentTimer = null;
                }
            }

            // 更新完整 intent
            action.tool.intent_full = newIntent;

            // 判断是否是历史恢复：只有从头重建时才直接显示
            const isHistoryRestore = this._rebuildingFromScratch;

            if (isHistoryRestore) {
                // 历史恢复，直接显示完整 intent
                action.tool.intent_rendered = newIntent;
                debugLog('[TaskPolling] 历史恢复，直接显示 intent');
            } else {
                // 新工具块，逐字符显示
                debugLog('[TaskPolling] 新工具块，开始打字机效果');
                action.tool.intent_rendered = '';
                action.tool._intentTyping = true;

                // 计算每个字符的间隔时间
                // 总时长1秒，但最少0.5秒
                const totalDuration = Math.max(500, Math.min(1000, newIntent.length * 50));
                const charInterval = totalDuration / newIntent.length;

                let charIndex = 0;
                const typeNextChar = () => {
                    if (charIndex < newIntent.length && action.tool._intentTyping) {
                        action.tool.intent_rendered += newIntent[charIndex];
                        charIndex++;
                        this.$forceUpdate();
                        action.tool._intentTimer = setTimeout(typeNextChar, charInterval);
                    } else {
                        action.tool._intentTyping = false;
                        action.tool.intent_rendered = newIntent; // 确保完整
                        action.tool._intentTimer = null;
                        this.$forceUpdate();
                    }
                };

                action.tool._intentTimer = setTimeout(typeNextChar, 50); // 延迟50ms开始
            }

            // 更新 arguments 和 label
            if (action.tool.arguments) {
                action.tool.arguments.intent = newIntent;
                action.tool.argumentSnapshot = this.cloneToolArguments(action.tool.arguments);
                action.tool.argumentLabel = this.buildToolLabel(action.tool.argumentSnapshot);
            }

            this.$forceUpdate();
            debugLog('[TaskPolling] 已更新工具意图:', data.name);
        } else {
            debugLog('[TaskPolling] 未找到对应的工具 action:', data.id);
        }
    },

    handleToolUpdateAction(data: any) {
        if (this.dropToolEvents) {
            return;
        }

        debugLog('[TaskPolling] 更新action:', data.id, 'status:', data.status);

        let targetAction = this.toolFindAction(data.id, data.preparing_id, data.execution_id);
        if (!targetAction && data.preparing_id && this.preparingTools.has(data.preparing_id)) {
            targetAction = this.preparingTools.get(data.preparing_id);
        }

        if (!targetAction) {
            return;
        }

        if (data.status) {
            targetAction.tool.status = data.status;
        }
        if (data.result !== undefined) {
            targetAction.tool.result = data.result;
        }
        if (data.message !== undefined) {
            targetAction.tool.message = data.message;
        }
        if (data.content !== undefined) {
            targetAction.tool.content = data.content;
        }

        this.$forceUpdate();
        this.conditionalScrollToBottom();

        if (this.monitorResolveTool && data.status === 'completed') {
            this.monitorResolveTool(data);
        }
    },

    handleAppendPayload(data: any) {
        debugLog('[TaskPolling] 文件追加:', data.path);
        this.chatAddAppendPayloadAction(data);
        this.$forceUpdate();
        this.conditionalScrollToBottom();
    },

    handleModifyPayload(data: any) {
        debugLog('[TaskPolling] 文件修改:', data.path);
        this.chatAddModifyPayloadAction(data);
        this.$forceUpdate();
        this.conditionalScrollToBottom();
    },

    markLatestUserWorkCompleted() {
        if (!Array.isArray(this.messages) || this.messages.length === 0) {
            return;
        }
        for (let i = this.messages.length - 1; i >= 0; i -= 1) {
            const msg = this.messages[i];
            if (!msg || msg.role !== 'user') {
                continue;
            }
            msg.metadata = msg.metadata || {};
            msg.metadata.work_timer = msg.metadata.work_timer || {};
            const timer = msg.metadata.work_timer;
            if (timer.status === 'completed' && typeof timer.duration_ms === 'number') {
                return;
            }
            const nowIso = new Date().toISOString();
            const startedAt = timer.started_at || msg.timestamp || nowIso;
            const startMs = Date.parse(startedAt);
            const endMs = Date.now();
            const durationMs = Number.isFinite(startMs) ? Math.max(0, endMs - startMs) : 0;
            timer.status = 'completed';
            timer.started_at = startedAt;
            timer.finished_at = nowIso;
            timer.duration_ms = durationMs;
            return;
        }
    },

    handleTaskComplete(data: any) {
        const hasRunningSubAgents = !!data?.has_running_sub_agents;
        if (hasRunningSubAgents) {
            debugLog('[TaskPolling] 任务完成，但仍有后台子智能体运行');
        } else {
            debugLog('[TaskPolling] 任务完成');
        }

        // 同步处理状态更新
        this.streamingMessage = false;
        this.stopRequested = false;
        if (!hasRunningSubAgents) {
            this.markLatestUserWorkCompleted();
        }

        if (hasRunningSubAgents) {
            this.taskInProgress = true;
            this.waitingForSubAgent = true;
        } else {
            this.taskInProgress = false;
            this.waitingForSubAgent = false;
            this.clearTaskState(); // 清理任务状态
        }

        this.$forceUpdate();

        // 只更新统计，不重新加载历史
        if (this.currentConversationId) {
            setTimeout(() => {
                this.fetchConversationTokenStatistics();
                this.updateCurrentContextTokens();
            }, 500);
        }
    },

    handleTaskStopped(data: any, eventIdx: number) {
        debugLog('[TaskPolling] 任务已停止, idx:', eventIdx, data);

        this.markLatestUserWorkCompleted();
        this.streamingMessage = false;
        this.taskInProgress = false;
        this.stopRequested = false;
        this.waitingForSubAgent = false;

        if (typeof this.clearPendingTools === 'function') {
            this.clearPendingTools('task_stopped');
        }
        this.$forceUpdate();

        this.clearTaskState();
    },

    // 新增统一清理方法
    clearTaskState() {
        (async () => {
            const { useTaskStore } = await import('../../stores/task');
            const taskStore = useTaskStore();
            taskStore.clearTask(); // 使用 clearTask 而不是 stopPolling
        })();

        if (typeof this.clearProcessedEvents === 'function') {
            this.clearProcessedEvents();
        }
    },

    handleUserMessage(data: any) {
        const message = (data?.message || data?.content || '').trim();
        if (!message) {
            return;
        }
        debugLog('[TaskPolling] 收到用户消息事件');
        this.chatAddUserMessage(message, data?.images || [], data?.videos || []);
        this.taskInProgress = true;
        this.streamingMessage = false;
        this.stopRequested = false;
        if (data?.sub_agent_notice) {
            if (typeof data?.has_running_sub_agents === 'boolean') {
                this.waitingForSubAgent = data.has_running_sub_agents;
            } else if (typeof data?.remaining_count === 'number') {
                this.waitingForSubAgent = data.remaining_count > 0;
            }
        }
        this.$forceUpdate();
        this.conditionalScrollToBottom();
    },

    handleTaskError(data: any) {
        const shouldRetry = Boolean(data?.retry);
        if (shouldRetry) {
            const retryIn = Number(data?.retry_in) || 5;
            const attempt = Number(data?.attempt) || 1;
            const maxAttempts = Number(data?.max_attempts) || attempt;

            debugLog('[TaskPolling] API错误，等待自动重试', {
                retryIn,
                attempt,
                maxAttempts,
                message: data?.message
            });

            this.stopRequested = false;
            this.taskInProgress = true;
            this.streamingMessage = true;
            this.$forceUpdate();

            this.uiPushToast({
                title: '即将重试',
                message: `将在 ${retryIn} 秒后重试（第 ${attempt}/${maxAttempts} 次）`,
                type: 'info',
                duration: Math.max(retryIn, 1) * 1000
            });
            return;
        }

        const errorMessage = data.message || '未知错误';
        const errorType = data.error_type || 'unknown';

        let title = '任务执行失败';
        let message = errorMessage;

        // 根据错误类型提供友好提示
        if (errorType === 'api_error') {
            title = 'API 调用失败';
            message = `模型服务异常：${errorMessage}`;
        } else if (errorType === 'timeout') {
            title = '任务超时';
            message = '任务执行时间过长，已自动停止';
        } else if (errorType === 'quota_exceeded') {
            title = '配额不足';
            message = '您的使用配额已用尽';
        }

        console.error('[TaskPolling] 任务错误:', data.message);
        this.uiPushToast({
            title,
            message,
            type: 'error',
            duration: 8000
        });

        // 清理状态
        this.markLatestUserWorkCompleted();
        this.streamingMessage = false;
        this.taskInProgress = false;
        this.stopRequested = false;
        this.$forceUpdate();

        // 停止轮询
        (async () => {
            const { useTaskStore } = await import('../../stores/task');
            const taskStore = useTaskStore();
            taskStore.stopPolling();
        })();
    },

    handleTokenUpdate(data: any) {
        if (data.conversation_id === this.currentConversationId) {
            this.currentConversationTokens.cumulative_input_tokens = data.cumulative_input_tokens || 0;
            this.currentConversationTokens.cumulative_output_tokens = data.cumulative_output_tokens || 0;
            this.currentConversationTokens.cumulative_total_tokens = data.cumulative_total_tokens || 0;

            if (typeof data.current_context_tokens === 'number') {
                this.resourceSetCurrentContextTokens(data.current_context_tokens);
            } else {
                this.updateCurrentContextTokens();
            }

            this.$forceUpdate();
        }
    },

    handleConversationChanged(data: any, eventIdx: number) {
        debugLog('[TaskPolling] 对话标题已更新, idx:', eventIdx, data);

        if (data && data.conversation_id === this.currentConversationId) {
            // 更新当前对话标题
            if (data.title) {
                this.currentConversationTitle = data.title;
                debugLog('[TaskPolling] 更新当前对话标题:', data.title);
            }

            // 更新对话列表中的标题
            if (data.title && Array.isArray(this.conversations)) {
                const conv = this.conversations.find(c => c && c.id === data.conversation_id);
                if (conv) {
                    conv.title = data.title;
                    debugLog('[TaskPolling] 更新对话列表中的标题:', data.title);
                }
            }

            this.$forceUpdate();
        }
    },

    handleConversationResolved(data: any) {
        if (data && data.conversation_id) {
            this.currentConversationId = data.conversation_id;
            if (data.title) {
                this.currentConversationTitle = data.title;
            }
            this.promoteConversationToTop(data.conversation_id);

            const pathFragment = this.stripConversationPrefix(data.conversation_id);
            const currentPath = window.location.pathname.replace(/^\/+/, '');
            if (data.created) {
                history.pushState({ conversationId: data.conversation_id }, '', `/${pathFragment}`);
            } else if (currentPath !== pathFragment) {
                history.replaceState({ conversationId: data.conversation_id }, '', `/${pathFragment}`);
            }
        }
    },

    /**
     * 清理已处理的事件索引
     */
    clearProcessedEvents() {
        if (this._processedEventIndices) {
            this._processedEventIndices.clear();
        }
    },

    /**
     * 恢复任务状态（页面刷新后调用）
     */
    async restoreTaskState() {
        // 清理已处理的事件索引
        this.clearProcessedEvents();

        try {
            const { useTaskStore } = await import('../../stores/task');
            const taskStore = useTaskStore();

            // 如果已经在流式输出中，不重复恢复
            if (this.streamingMessage || this.taskInProgress) {
                debugLog('[TaskPolling] 任务已在进行中，跳过恢复', {
                    streamingMessage: this.streamingMessage,
                    taskInProgress: this.taskInProgress,
                    currentConversationId: this.currentConversationId
                });
                return;
            }

            // 查找运行中的任务
            const runningTask = await taskStore.loadRunningTask(this.currentConversationId);

            if (!runningTask) {
                debugLog('[TaskPolling] 没有运行中的任务', {
                    currentConversationId: this.currentConversationId
                });
                await this.restoreSubAgentWaitingState();
                return;
            }

            debugLog('[TaskPolling] 发现运行中的任务，开始恢复状态', {
                taskId: runningTask?.task_id,
                status: runningTask?.status,
                conversationId: runningTask?.conversation_id
            });

            // 检查历史是否已加载
            const hasMessages = Array.isArray(this.messages) && this.messages.length > 0;

            if (!hasMessages) {
                debugLog('[TaskPolling] 历史未加载，等待历史加载完成');
                setTimeout(() => {
                    this.restoreTaskState();
                }, 500);
                return;
            }

            debugLog('[TaskPolling] 历史已加载，开始精细恢复');

            // 获取任务的所有事件
            const detailResponse = await fetch(`/api/tasks/${taskStore.currentTaskId}`);
            if (!detailResponse.ok) {
                debugLog('[TaskPolling] 获取任务详情失败');
                return;
            }

            const detailResult = await detailResponse.json();
            if (!detailResult.success || !detailResult.data.events) {
                debugLog('[TaskPolling] 任务详情无效');
                return;
            }

            const allEvents = detailResult.data.events;
            debugLog(`[TaskPolling] 获取到 ${allEvents.length} 个事件`);

            // 找到最后一条消息
            const lastMessage = this.messages[this.messages.length - 1];
            const isAssistantMessage = lastMessage && lastMessage.role === 'assistant';

            // console.log('[TaskPolling] 最后一条消息:', {
            //     exists: !!lastMessage,
            //     role: lastMessage?.role,
            //     actionsCount: lastMessage?.actions?.length || 0,
            //     isAssistant: isAssistantMessage
            // });

            // 检查是否需要从头重建
            // 1. 最后一条不是 assistant 消息
            // 2. 最后一条是空的 assistant 消息
            // 3. 事件数量远大于历史中的 actions 数量（说明历史不完整）
            const historyActionsCount = lastMessage?.actions?.length || 0;
            const eventCount = allEvents.length;
            const historyIncomplete = eventCount > historyActionsCount + 5; // 允许5个事件的误差

            const needsRebuild = !isAssistantMessage ||
                                 (isAssistantMessage && (!lastMessage.actions || lastMessage.actions.length === 0)) ||
                                 historyIncomplete;

            if (needsRebuild) {
                // if (historyIncomplete) {
                //     console.log('[TaskPolling] 历史不完整，从头重建:', {
                //         historyActionsCount,
                //         eventCount,
                //         diff: eventCount - historyActionsCount
                //     });
                // }
                debugLog('[TaskPolling] 需要从头重建 assistant 响应');

                // 清空所有消息，准备从头重建
                // 保留用户消息，只删除最后的 assistant 消息
                if (isAssistantMessage) {
                    debugLog('[TaskPolling] 删除不完整的 assistant 消息');
                    this.messages.pop();
                }

                this.streamingMessage = true;
                this.taskInProgress = true;
                this.$forceUpdate();

                // 重置偏移量为 0，从头获取所有事件来重建 assistant 消息
                taskStore.lastEventIndex = 0;
                debugLog('[TaskPolling] 重置偏移量为 0，从头开始轮询');

                // 标记正在从头重建，用于后续处理
                this._rebuildingFromScratch = true;
                this._rebuildingEventCount = allEvents.length; // 记录当前事件总数

                (window as any).__taskEventHandler = (event: any) => {
                    this.handleTaskEvent(event);
                };

                taskStore.startPolling((event: any) => {
                    this.handleTaskEvent(event);
                });

                // 延迟清除重建标记，确保所有历史事件都处理完毕
                setTimeout(() => {
                    debugLog('[TaskPolling] 历史事件处理完毕，清除重建标记');
                    this._rebuildingFromScratch = false;
                    this._rebuildingEventCount = 0;
                }, 2000);

                return;
            }

            // 分析事件，找到当前正在进行的操作
            let inThinking = false;
            let inText = false;

            for (let i = 0; i < allEvents.length; i++) {
                const event = allEvents[i];

                if (event.type === 'thinking_start') {
                    inThinking = true;
                } else if (event.type === 'thinking_end') {
                    inThinking = false;
                }

                if (event.type === 'text_start') {
                    inText = true;
                } else if (event.type === 'text_end') {
                    inText = false;
                }
            }

            // console.log('[TaskPolling] 分析结果:', {
            //     inThinking,
            //     inText,
            //     totalEvents: allEvents.length,
            //     lastEventType: allEvents[allEvents.length - 1]?.type,
            //     lastEventIdx: allEvents[allEvents.length - 1]?.idx
            // });

            // 恢复思考块状态
            if (lastMessage.actions) {
                // console.log('[TaskPolling] 历史中的 actions 详情:', lastMessage.actions.map((a, idx) => ({
                //     index: idx,
                //     type: a.type,
                //     id: a.id,
                //     hasContent: !!a.content,
                //     contentLength: a.content?.length || 0,
                //     toolName: a.tool?.name,
                //     hasBlockId: !!a.blockId,
                //     blockId: a.blockId,
                //     collapsed: a.collapsed,
                //     streaming: a.streaming
                // })));

                const thinkingActions = lastMessage.actions.filter(a => a.type === 'thinking');
                // console.log('[TaskPolling] 思考块数量:', thinkingActions.length);

                if (inThinking && thinkingActions.length > 0) {
                    // 正在思考中，检查最后一个思考块是否正在流式输出
                    const lastThinking = thinkingActions[thinkingActions.length - 1];

                    // 只有当思考块正在流式输出时才设置锁定状态（但不展开）
                    if (lastThinking.streaming && lastThinking.blockId) {
                        // console.log('[TaskPolling] 找到正在流式输出的思考块，设置锁定状态:', lastThinking.blockId);
                        this.$nextTick(() => {
                            this.chatSetThinkingLock(lastThinking.blockId, true);
                        });
                    }
                }

                // 确保所有思考块都是折叠状态
                for (const thinking of thinkingActions) {
                    if (thinking.blockId) {
                        thinking.collapsed = true;
                    }
                }

                // 检查思考块状态（在设置之后）（已禁用）
                // thinkingActions.forEach((thinking, idx) => {
                //     console.log(`[TaskPolling] 思考块 ${idx} (设置后):`, {
                //         hasBlockId: !!thinking.blockId,
                //         blockId: thinking.blockId,
                //         collapsed: thinking.collapsed,
                //         contentLength: thinking.content?.length || 0
                //     });
                // });

                // 恢复文本块状态
                const textActions = lastMessage.actions.filter(a => a.type === 'text');
                // console.log('[TaskPolling] 文本块数量:', textActions.length);

                if (inText && textActions.length > 0) {
                    const lastText = textActions[textActions.length - 1];
                    // console.log('[TaskPolling] 标记文本块为流式状态');
                    lastText.streaming = true;
                }

                // 注册历史中的工具块到 toolActionIndex
                // 这样后续的 update_action 事件可以找到对应的块进行状态更新
                const toolActions = lastMessage.actions.filter(a => a.type === 'tool');
                // console.log('[TaskPolling] 工具块数量:', toolActions.length);

                for (const toolAction of toolActions) {
                    if (toolAction.tool && toolAction.tool.id) {
                        // console.log('[TaskPolling] 注册工具块:', {
                        //     id: toolAction.tool.id,
                        //     name: toolAction.tool.name,
                        //     status: toolAction.tool.status
                        // });
                        // 注册到 toolActionIndex
                        this.toolRegisterAction(toolAction, toolAction.tool.id);
                        // 如果有 executionId，也注册
                        if (toolAction.tool.executionId) {
                            this.toolRegisterAction(toolAction, toolAction.tool.executionId);
                        }
                        // 追踪工具调用
                        if (toolAction.tool.name) {
                            this.toolTrackAction(toolAction.tool.name, toolAction);
                        }
                    }
                }
            }

            // 标记状态为进行中
            this.streamingMessage = true;
            this.taskInProgress = true;

            // 设置 currentMessageIndex 指向最后一条 assistant 消息
            // 这样后续添加的 action 会添加到正确的消息中
            const lastMessageIndex = this.messages.length - 1;
            if (lastMessage && lastMessage.role === 'assistant') {
                this.currentMessageIndex = lastMessageIndex;
                // console.log('[TaskPolling] 设置 currentMessageIndex 为:', lastMessageIndex);
            }

            // 强制更新界面
            this.$forceUpdate();

            // 滚动到底部
            this.$nextTick(() => {
                this.conditionalScrollToBottom();
            });

            // 注册事件处理器到全局
            (window as any).__taskEventHandler = (event: any) => {
                this.handleTaskEvent(event);
            };

            // 启动轮询（从当前偏移量开始，只处理新事件）
            debugLog('[TaskPolling] 启动轮询，起始偏移量:', taskStore.lastEventIndex);

            taskStore.startPolling((event: any) => {
                this.handleTaskEvent(event);
            });

            this.uiPushToast({
                title: '任务恢复',
                message: '检测到进行中的任务，已恢复连接',
                type: 'info',
                duration: 3000
            });
        } catch (error) {
            console.error('[TaskPolling] 恢复任务状态失败:', error);
        }
    },

    /**
     * 恢复子智能体等待状态（页面刷新后调用）
     */
    async restoreSubAgentWaitingState(retry = 0) {
        try {
            if (!this.currentConversationId) {
                if (retry < 5) {
                    setTimeout(() => {
                        this.restoreSubAgentWaitingState(retry + 1);
                    }, 300);
                }
                return;
            }

            const response = await fetch('/api/sub_agents');
            if (!response.ok) {
                debugLog('[TaskPolling] 获取子智能体状态失败');
                return;
            }
            const result = await response.json();
            if (!result.success) {
                debugLog('[TaskPolling] 子智能体状态响应无效');
                return;
            }

            const tasks = Array.isArray(result.data) ? result.data : [];
            debugLog('[TaskPolling] 子智能体状态响应', {
                total: tasks.length,
                currentConversationId: this.currentConversationId,
                tasks: tasks.map((task: any) => ({
                    task_id: task?.task_id,
                    status: task?.status,
                    run_in_background: task?.run_in_background,
                    notice_pending: task?.notice_pending,
                    conversation_id: task?.conversation_id
                }))
            });
            const terminalStatuses = new Set(['completed', 'failed', 'timeout', 'terminated']);
            const relevant = tasks.filter((task: any) => {
                if (task && task.conversation_id && task.conversation_id !== this.currentConversationId) {
                    return false;
                }
                return true;
            });

            const running = relevant.filter((task: any) => task?.run_in_background && !terminalStatuses.has(task?.status));
            const pendingNotice = relevant.filter((task: any) => task?.notice_pending);

            if (running.length || pendingNotice.length) {
                debugLog('[TaskPolling] 恢复子智能体等待状态', {
                    running: running.length,
                    pendingNotice: pendingNotice.length,
                    runningTasks: running.map((task: any) => ({ task_id: task?.task_id, status: task?.status })),
                    pendingTasks: pendingNotice.map((task: any) => ({ task_id: task?.task_id, status: task?.status }))
                });
                this.waitingForSubAgent = true;
                this.taskInProgress = true;
                this.streamingMessage = false;
                this.stopRequested = false;
                this.$forceUpdate();
            }
        } catch (error) {
            console.error('[TaskPolling] 恢复子智能体等待状态失败:', error);
        }
    },
};