import $i18n from '../../../locales/i18n.js';
import { useState, useCallback, useRef, useEffect } from 'react';
import { CnMessage } from '@cainiaofe/cn-ui';
import { submitOrderFollowBriefTask, queryFollowOrderTaskByJobId } from '../services';
import { formatColumnDefinitions } from '../../../cn-ai-agent/utils/format-column-definitions';
import { formatRelatedData } from '../../../cn-ai-agent/utils/format-related-data';
import { POLLING_INTERVAL, MAX_POLLING_COUNT } from './constants';
import { isEditor } from '../../../utils/env/index.js';
import { rowDataCache } from '../components/common/hooks/row-data-cache';
/**
 * 获取当前用户工号
 */
const getAliWorkNo = () => { var _a, _b, _c; return ((_b = (_a = window.__PAGE_INFO__) === null || _a === void 0 ? void 0 : _a.user) === null || _b === void 0 ? void 0 : _b.aliWorkNo) || ((_c = window === null || window === void 0 ? void 0 : window._GATEWAY_PF) === null || _c === void 0 ? void 0 : _c.workerNo); };
const INITIAL_TASK_STATE = {
    loading: false,
    accumulatedTasks: [],
    needAttentionRowIds: [],
};
/** 稳定的空数组引用，避免每次返回新数组导致下游重渲染 */
const EMPTY_TASKS = [];
// ==================== Hook 实现 ====================
/**
 * 智能跟单 Hook（总览任务）
 *
 * 流程：
 * 1. 页面进入时提交跟单总览任务（submitOrderFollowBriefTask），获取 followOrderJobId
 * 2. 通过 queryFollowOrderTaskByJobId 轮询任务结果，每次传入 jobId 和上次的 lastChunkId 作为 startingId
 * 3. 接口增量返回需要跟单的内容（无需再全局聚合），根据 finished 字段判断是否继续轮询
 * 4. 轮询结束后一次性 flush 累积的 needAttentionRowIds 到 state
 *
 * 注意：
 * - 此 Hook 只负责判断哪些行需要跟单
 * - 单条跟单详情（jobOutput）需要在视图层通过 submitOrderFollowDetailTask 单独请求
 * - Hook 内部在轮询中会增量更新 needAttentionRowIds，但主表格是否展示由视图层
 *   （table-view.tsx 中的 deferredNeedAttentionRowIds）控制，轮询期间不回显、
 *   轮询结束后一次性写入。修改本 Hook 时无需关心表格高亮时机。
 */
export function useSmartFollow(options) {
    const { tableId, formattedTableData, columnDefinitions, enabled = true, bizRequestConfig, } = options;
    const enabledRef = useRef(enabled);
    enabledRef.current = enabled;
    // ==================== 状态 ====================
    const [taskState, setTaskState] = useState(INITIAL_TASK_STATE);
    const [conversationId, setConversationId] = useState(null);
    const [respMessageId, setRespMessageId] = useState(null);
    // submitOrderFollowBriefTask 返回的 followOrderJobId，用于后续轮询
    const followOrderJobIdRef = useRef(null);
    // 上次轮询返回的 lastChunkId，作为下次轮询的 startingId
    const lastChunkIdRef = useRef(undefined);
    // 轮询定时器
    const pollingTimerRef = useRef(null);
    // 轮询计数
    const pollingCountRef = useRef(0);
    // 是否正在轮询中
    const isPollingRef = useRef(false);
    // 是否已初始化
    const isInitializedRef = useRef(false);
    // 是否发生API失败（用于停止轮询）
    const hasApiFailureRef = useRef(false);
    // 轮询中间结果（轮询期间只写 ref 不触发渲染，轮询结束时一次性 flush 到 state）
    const pollingResultRef = useRef({ tasks: [], needAttentionRowIds: [] });
    // 始终指向最新的 submitBriefTask，让 refresh 不依赖其引用变化
    const submitBriefTaskRef = useRef(() => { });
    // ==================== 轮询控制 ====================
    /** 停止轮询，并将 ref 中积累的中间结果一次性 flush 到 state */
    const stopPolling = useCallback(() => {
        if (pollingTimerRef.current) {
            clearTimeout(pollingTimerRef.current);
            pollingTimerRef.current = null;
        }
        pollingCountRef.current = 0;
        isPollingRef.current = false;
        hasApiFailureRef.current = false;
        const result = pollingResultRef.current;
        setTaskState({
            loading: false,
            accumulatedTasks: result.tasks,
            needAttentionRowIds: result.needAttentionRowIds,
        });
    }, []);
    /** 执行一次轮询查询（基于 jobId 增量获取需要跟单的内容） */
    const pollOnce = useCallback(async () => {
        const jobId = followOrderJobIdRef.current;
        if (!jobId)
            return false;
        try {
            const result = await queryFollowOrderTaskByJobId({
                jobId,
                startingId: lastChunkIdRef.current,
            }, bizRequestConfig);
            if (!result) {
                hasApiFailureRef.current = true;
                CnMessage.error($i18n.get({
                    id: 'SmartDocumentaryTaskQueryFailedP_469459030',
                    dm: '智能跟单任务查询失败，已停止轮询',
                }));
                return false;
            }
            const { finished, lastChunkId, needAttentionTasks = [] } = result;
            // 记录 lastChunkId，作为下次轮询的 startingId
            if (lastChunkId) {
                lastChunkIdRef.current = lastChunkId;
            }
            // 接口现在只返回需要跟单的内容，无需再全局聚合，直接累积
            if (needAttentionTasks.length > 0) {
                const newRowIds = needAttentionTasks.map((t) => t.rowId);
                pollingResultRef.current.tasks = [...pollingResultRef.current.tasks, ...needAttentionTasks];
                pollingResultRef.current.needAttentionRowIds = [
                    ...pollingResultRef.current.needAttentionRowIds,
                    ...newRowIds,
                ];
            }
            // 根据 finished 字段判断是否需要继续轮询
            return !finished;
        }
        catch (error) {
            hasApiFailureRef.current = true;
            CnMessage.error((error === null || error === void 0 ? void 0 : error.message) ||
                $i18n.get({
                    id: 'IntelligentDocumentaryTaskQueryE_1319576668',
                    dm: '智能跟单任务查询异常，已停止轮询',
                }));
            return false;
        }
    }, [tableId, bizRequestConfig]);
    /** 启动轮询 */
    const startPolling = useCallback(() => {
        if (isPollingRef.current)
            return;
        // 重置失败标记
        hasApiFailureRef.current = false;
        isPollingRef.current = true;
        pollingCountRef.current = 0;
        setTaskState((prev) => ({ ...prev, loading: true }));
        const poll = async () => {
            pollingCountRef.current += 1;
            // 检查是否发生API失败
            if (hasApiFailureRef.current) {
                stopPolling();
                return;
            }
            if (pollingCountRef.current > MAX_POLLING_COUNT) {
                stopPolling();
                return;
            }
            // 执行一次轮询
            const hasMoreTasks = await pollOnce();
            // 再次检查是否发生API失败（pollOnce中可能设置了失败标记）
            if (hasApiFailureRef.current) {
                stopPolling();
                return;
            }
            if (hasMoreTasks) {
                // 继续轮询
                pollingTimerRef.current = setTimeout(poll, POLLING_INTERVAL);
            }
            else {
                // 所有任务完成
                stopPolling();
            }
        };
        // 立即开始第一次轮询
        poll();
    }, [pollOnce, stopPolling]);
    // ==================== 提交任务 ====================
    /** 提交跟单总览任务（用于判断哪些行需要跟单） */
    const submitBriefTask = useCallback(async (briefOptions) => {
        if (!enabledRef.current)
            return;
        if (!tableId || !(formattedTableData === null || formattedTableData === void 0 ? void 0 : formattedTableData.length) || !(columnDefinitions === null || columnDefinitions === void 0 ? void 0 : columnDefinitions.length) || isEditor) {
            return;
        }
        const { forcePrompt = false } = briefOptions || {};
        // 过滤掉 AI 字段的列定义
        const nonAiColumnDefinitions = columnDefinitions.filter((col) => !col.isAiColumn && col.format !== 'ai-generate');
        // 获取 AI 字段的 dataIndex 列表，用于过滤行数据
        const aiColumnDataIndexes = new Set(columnDefinitions
            .filter((col) => col.isAiColumn || col.format === 'ai-generate')
            .map((col) => col.dataIndex));
        // 格式化参数（不包含 AI 字段）
        const formattedColumnDefs = formatColumnDefinitions(nonAiColumnDefinitions);
        // 过滤行数据中的 AI 字段
        const nonAiTableData = formattedTableData.map((row) => {
            const filteredRow = {};
            Object.keys(row).forEach((key) => {
                if (!aiColumnDataIndexes.has(key)) {
                    filteredRow[key] = row[key];
                }
            });
            return filteredRow;
        });
        const formattedRowData = formatRelatedData(nonAiTableData);
        // 写入行 DTO 缓存，供 detail hook 复用同一数据源
        rowDataCache.setBatch(tableId, formattedRowData);
        setTaskState((prev) => ({ ...prev, loading: true }));
        try {
            // 提交跟单总览任务（用于获取哪些行需要关注）
            const result = await submitOrderFollowBriefTask({
                tableId,
                columnDefinitions: formattedColumnDefs,
                rowDataDTOS: formattedRowData,
                userId: getAliWorkNo(),
                conversationId,
                forcePrompt,
            }, bizRequestConfig);
            if (result) {
                const { conversationId: newConversationId, respMessageId: newRespMessageId, followOrderJobId, } = result;
                if (newConversationId)
                    setConversationId(newConversationId);
                if (newRespMessageId)
                    setRespMessageId(newRespMessageId);
                // 存储 jobId，用于后续 queryFollowOrderTaskByJobId 轮询
                followOrderJobIdRef.current = followOrderJobId;
            }
            startPolling();
        }
        catch {
            setTaskState((prev) => ({ ...prev, loading: false }));
        }
    }, [
        tableId,
        formattedTableData,
        columnDefinitions,
        conversationId,
        startPolling,
        bizRequestConfig,
    ]);
    // 同步 ref，确保 refresh 始终调用最新版本
    submitBriefTaskRef.current = submitBriefTask;
    /** 刷新（重新提交总览任务），支持强制重刷和会话重置 */
    const refresh = useCallback((refreshOptions) => {
        const { forcePrompt = false, resetConversation = false } = refreshOptions || {};
        stopPolling();
        setTaskState(INITIAL_TASK_STATE);
        pollingResultRef.current = { tasks: [], needAttentionRowIds: [] };
        followOrderJobIdRef.current = null;
        lastChunkIdRef.current = undefined;
        // 清除行 DTO 缓存，重跑时会写入最新数据
        rowDataCache.clearByTableId(tableId);
        // 标准变更场景：重置会话上下文以避免沿用旧上下文
        if (resetConversation) {
            setConversationId(null);
            setRespMessageId(null);
        }
        // 通过 ref 调用，避免 refresh 依赖 submitBriefTask 导致引用频繁变化
        submitBriefTaskRef.current({ forcePrompt });
    }, [stopPolling, tableId]);
    // ==================== 生命周期 ====================
    // 页面进入时自动提交总览任务（用于判断哪些行需要跟单）
    useEffect(() => {
        if (enabled && tableId && (formattedTableData === null || formattedTableData === void 0 ? void 0 : formattedTableData.length) && !isInitializedRef.current) {
            isInitializedRef.current = true;
            if (!isEditor) {
                submitBriefTask();
            }
        }
    }, [enabled, tableId, formattedTableData === null || formattedTableData === void 0 ? void 0 : formattedTableData.length, submitBriefTask]);
    // 关闭跟单时停止轮询与未决请求，避免开关关闭后仍打跟单接口
    useEffect(() => {
        if (!enabled) {
            if (pollingTimerRef.current) {
                clearTimeout(pollingTimerRef.current);
                pollingTimerRef.current = null;
            }
            isInitializedRef.current = false;
            followOrderJobIdRef.current = null;
            lastChunkIdRef.current = undefined;
            pollingResultRef.current = { tasks: [], needAttentionRowIds: [] };
            pollingCountRef.current = 0;
            isPollingRef.current = false;
            hasApiFailureRef.current = false;
            setTaskState(INITIAL_TASK_STATE);
            setConversationId(null);
            setRespMessageId(null);
            if (tableId) {
                rowDataCache.clearByTableId(tableId);
            }
        }
    }, [enabled, tableId]);
    // 组件卸载时清理
    useEffect(() => {
        return () => {
            if (pollingTimerRef.current) {
                clearTimeout(pollingTimerRef.current);
            }
        };
    }, []);
    // ==================== 返回值 ====================
    return {
        loading: taskState.loading,
        needAttentionRowIds: taskState.needAttentionRowIds,
        finishedTasks: taskState.accumulatedTasks,
        failedTasks: EMPTY_TASKS,
        runningTasks: EMPTY_TASKS,
        conversationId,
        respMessageId,
        refresh,
    };
}
