"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.usePollResponse = void 0;
const i18n_1 = __importDefault(require("../../locales/i18n.js"));
const react_1 = __importDefault(require("react"));
const ai_agent_service_1 = require("../services/ai-agent-service");
const polling_constants_1 = require("../constants/polling-constants");
/**
 * 轮询查询响应的 Hook
 * 持续轮询查询 AI 响应状态，直到生成完成或超时
 */
const usePollResponse = () => {
    const pollResponse = react_1.default.useCallback(async (params) => {
        var _a;
        const { conversationId, // 会话 ID
        messageId, // 消息 ID（respMessageId）
        placeholderMessageId, // 占位符消息 ID，用于在消息列表中找到并更新消息
        setMessages, // 更新消息列表的函数
        setIsPolling, // 设置轮询状态的函数（用于 UI 显示加载状态）
        pollingTimerRef, // 定时器引用，存储 setTimeout 返回值，用于清理定时器
        pollingCountRef, // 轮询计数引用，记录每个轮询任务的次数（key: pollKey, value: 次数）
        isMountedRef, // 组件挂载状态引用，避免组件卸载后更新状态
        setGeneratingMessageId, // 设置正在生成的消息 ID（用于控制逐字显示效果）
        bizRequestConfig, } = params;
        // 生成唯一键，用于区分不同的轮询任务
        // 虽然当前实现中每次提交新消息时会清理之前的轮询，但设计上支持并发轮询
        // 这样可以防止：1) 快速连续发送消息时的竞态条件 2) 未来可能的多会话场景
        const pollKey = `${conversationId}-${messageId}`;
        // 获取当前轮询次数并递增（从 1 开始计数，用于超时检查）
        const currentCount = (pollingCountRef.current[pollKey] || 0) + 1;
        console.log(`🔄 [pollResponse] 开始轮询 (第 ${currentCount} 次):`, {
            conversationId,
            messageId,
            pollKey,
        });
        try {
            pollingCountRef.current[pollKey] = currentCount;
            // 超时检查
            if (currentCount > polling_constants_1.MAX_POLLING_COUNT) {
                console.warn('⏰ [pollResponse] 轮询超时，停止查询 (已达到最大次数)', {
                    pollKey,
                    count: currentCount,
                    maxCount: polling_constants_1.MAX_POLLING_COUNT,
                });
                // 更新消息为超时提示
                setMessages((prev) => {
                    // 找到占位符消息并替换为超时提示
                    const existingIndex = prev.findIndex((msg) => msg.id === placeholderMessageId);
                    if (existingIndex >= 0) {
                        const newMessages = [...prev];
                        newMessages[existingIndex] = {
                            role: 'assistant',
                            content: i18n_1.default.get({
                                id: 'QueryTimedOutPleaseTryAgainLater',
                                dm: '查询超时，请稍后重试。',
                            }),
                            id: placeholderMessageId,
                        };
                        return newMessages;
                    }
                    return prev;
                });
                // 清理轮询计数，避免内存泄漏
                delete pollingCountRef.current[pollKey];
                setGeneratingMessageId(null);
                // 直接返回，不进行后续轮询
                return;
            }
            const response = await (0, ai_agent_service_1.queryResponse)({ conversationId, messageId }, bizRequestConfig);
            console.log(`📊 [pollResponse] 收到响应 (第 ${currentCount} 次):`, {
                pollKey,
                onGoing: response.onGoing,
                hasText: !!response.text,
                textLength: ((_a = response.text) === null || _a === void 0 ? void 0 : _a.length) || 0,
                messageType: response.messageType,
            });
            // 更新占位符消息为实际响应内容
            // 若本次返回的 text 为空（如 onGoing: true 时接口先返回空），不替换当前展示内容，避免「正在生成回复」被清空造成割裂感
            setMessages((prev) => {
                const existingIndex = prev.findIndex((msg) => msg.id === placeholderMessageId);
                if (existingIndex >= 0) {
                    const hasNewText = response.text != null && String(response.text).trim() !== '';
                    const contentToSet = hasNewText ? response.text : prev[existingIndex].content;
                    const newMessages = [...prev];
                    newMessages[existingIndex] = {
                        role: 'assistant',
                        content: contentToSet,
                        id: placeholderMessageId,
                    };
                    return newMessages;
                }
                return prev;
            });
            // 根据 onGoing 状态决定是否继续轮询
            if (response.onGoing && isMountedRef.current) {
                console.log(`⏭️ [pollResponse] 继续轮询 (${polling_constants_1.POLLING_INTERVAL}ms 后)`, { pollKey });
                setIsPolling(true);
                pollingTimerRef.current = setTimeout(() => {
                    pollResponse(params);
                }, polling_constants_1.POLLING_INTERVAL);
            }
            else {
                console.log('✅ [pollResponse] 轮询完成，停止查询', {
                    pollKey,
                    totalPollCount: currentCount,
                });
                pollingTimerRef.current = null;
                setIsPolling(false);
                delete pollingCountRef.current[pollKey];
                setGeneratingMessageId(null);
            }
        }
        catch (error) {
            console.error('❌ [pollResponse] 轮询查询响应失败:', {
                pollKey,
                error,
                count: currentCount,
            });
            pollingTimerRef.current = null;
            setIsPolling(false);
            delete pollingCountRef.current[pollKey];
            setGeneratingMessageId(null);
        }
    }, []);
    return { pollResponse };
};
exports.usePollResponse = usePollResponse;
