"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DataModel = void 0;
const i18n_1 = __importDefault(require("../../locales/i18n.js")); // stores/dataModel.ts
const react_1 = __importDefault(require("react"));
const get_column_meta_data_1 = require("../../utils/data/get-column-meta-data.js");
const mobx_1 = require("mobx");
const primary_key_1 = require("./utils/primary-key");
const utils_1 = require("./utils");
const view_config_normalizer_1 = require("./utils/view-config-normalizer");
// import { updateDict } from '@/plugins/cn-ai-table-plugin/service/async-dict';
const customFilterFns_1 = require("./components/views/table-view/utils/filters/customFilterFns");
const formula_field_1 = require("./components/toolbar/components/add-field/formula-field");
const constants_1 = require("./hooks/constants");
const field_types_1 = require("./components/toolbar/components/add-field/constants/field-types");
const hooks_1 = require("../../hooks/index.js");
const services_1 = require("./services");
class DataModel {
    constructor() {
        /** 共享数据源 - 全量数据 */
        this.rawData = [];
        /** 原始列定义（从 props 传入的 columns） */
        this.originColumns = [];
        /** 列定义（字段定义） */
        this.columnDefinitions = []; // 列定义（字段定义）
        /** 当前活动的视图 ID */
        this.activeViewId = null;
        /** 视图配置：viewId -> 配置 */
        this.viewConfigs = new Map();
        /** 视图顺序数组（用于保持视图 tab 的排序） */
        this.viewOrder = [];
        /** 记录操作请求配置 */
        this.recordOperationRequestConfig = null;
        /** 表格选择信息（用于在分页栏显示选中数量） */
        this.selectKeys = [];
        /** 存储的选中项信息 */
        this.storeSelectInfo = [];
        /** 是否显示选中数量 */
        this.showSelectedNum = false;
        /** 当前视图（筛选/排序/分组后）结果集中被选中的条数，用于左下角「选中 x 项」；为 null 时用 selectKeys.length */
        this.selectedCountInCurrentView = null;
        /** AI列列表 */
        this.aiColumns = [];
        /** AI 单元格数据层（独立于原始数据） */
        this.aiCellData = new Map();
        /** 运行中的AI任务列表 */
        this.runningTasks = [];
        /** 智能跟单状态（只保存 needAttentionRowIds，） */
        this.smartFollowState = {
            loading: false,
            needAttentionRowIds: [],
            runningTasks: [],
            conversationId: null,
        };
        /** 主键字段名或取值函数，用于唯一标识每一行数据，由外部通过 setPrimaryKey 设置 */
        this.primaryKey = primary_key_1.DEFAULT_PRIMARY_KEY;
        /** 表格数据加载状态 */
        this.loading = false;
        /**
         * 视图显示顺序数据缓存
         * @description 存储每个视图当前页面实际显示的数据行顺序（考虑分组/筛选/排序）
         * key: viewId, value: 按显示顺序排列的数据行数组
         */
        this.displayOrderDataMap = new Map();
        /** 是否支持批量编辑（为 false 时整个表格不可编辑） */
        this.supportBatchEdit = false;
        /** 引用字段能力配置（由 resolvedConfig.fieldTypes.lookup 同步） */
        this.lookupFieldConfig = null;
        /** Grid 视图工具栏权限（由 resolvedConfig.viewTypes.grid.toolbarPermissions 同步）；列右键菜单等下游消费者直接 useModel 读取，避免逐层透传 */
        this.gridToolbarPermissions = null;
        /** 列头右键菜单关闭开关；true 时列头不绑 onContextMenu，浏览器走原生菜单 */
        this.hideColumnHeaderMenu = false;
        /**
         * 魔方用户配置表行主键（createOrUpdate 顶层 `id` / content 根级 `id`）。
         * 首次创建后由保存响应写入；后续更新作为 hint 传给 persist。
         */
        this.cubePlatformUserConfigRowId = '';
        /** 表级自定义字段配置（AI字段、公式字段等） */
        this.customFields = {
            aiConfig: {},
            aiColumns: [],
            formulaConfig: {},
            lookupConfig: {},
        };
        (0, mobx_1.makeAutoObservable)(this);
        // 默认不注入占位视图 tab，避免「构造器随机 id」与首轮 setAllViews 替换造成 tab 抖动；首屏就绪由 CnAiTable 在未 ready 时用 Loading 遮挡。
        this.viewConfigs = new Map();
        this.viewOrder = [];
        this.activeViewId = null;
    }
    /** 设置记录操作请求配置 */
    setRecordOperationRequestConfig(config) {
        this.recordOperationRequestConfig = config;
    }
    /** 设置表格ID */
    setTableId(tableId) {
        // 切换 tableId 时清空 userCubeConfigRowId，避免覆盖首次创建后尚未出现在列表中的缓存
        if (this.tableId !== tableId) {
            this.cubePlatformUserConfigRowId = '';
        }
        this.tableId = tableId;
    }
    /** 魔方开放平台用户配置行主键（与视图 save、AI 列 save 共用） */
    setCubePlatformUserConfigRowId(id) {
        this.cubePlatformUserConfigRowId = id;
    }
    /** 设置加载状态 */
    setLoading(loading) {
        this.loading = loading;
    }
    /** 设置智能跟单状态（只保存 needAttentionRowIds，） */
    setSmartFollowState(state) {
        this.smartFollowState = state;
    }
    /**
     * 设置主键字段名或取值函数
     * @param key 字符串字段名或自定义取值函数；传入空字符串等无效值时回落到默认主键
     */
    setPrimaryKey(key) {
        if (typeof key === 'function') {
            this.primaryKey = key;
        }
        else if (typeof key === 'string' && key) {
            this.primaryKey = key;
        }
        else {
            // if (process.env.NODE_ENV !== 'production' && key !== undefined && key !== null) {
            //   // eslint-disable-next-line no-console
            //   console.warn(
            //     `[cn-ai-table] setPrimaryKey: invalid value (${typeof key}); falling back to "${DEFAULT_PRIMARY_KEY}".`,
            //   );
            // }
            this.primaryKey = primary_key_1.DEFAULT_PRIMARY_KEY;
        }
    }
    /**
     * 获取行的唯一标识（带 rowIndex 兜底，保留原始类型）。
     *
     * 适用于：渲染、行选择、回传给业务方/服务端等需要保留原始 number/string 类型的场景。
     * Falsy 规则：`0` / `false` / `''` 视为有效；仅 `null` / `undefined` 触发 rowIndex 兜底。
     *
     * @param row 行数据
     * @param rowIndex 行索引，用于 primaryKey 取值为空时兜底
     * @returns 行的唯一标识值
     */
    getRowKey(row, rowIndex) {
        const pk = this.primaryKey || primary_key_1.DEFAULT_PRIMARY_KEY;
        return (0, primary_key_1.safeGetRowKey)(row, pk, rowIndex);
    }
    /**
     * 严格获取行唯一标识，**不做 rowIndex 兜底**。
     *
     * 适用于：服务端 rowId 上送、持久化、拖拽身份等不允许 index 兜底的场景。
     * 当 primaryKey 无法取到有效值时返回 `null`，调用方据此跳过该行或报错。
     */
    getRowKeyStrict(row) {
        const pk = this.primaryKey || primary_key_1.DEFAULT_PRIMARY_KEY;
        return (0, primary_key_1.getRowKeyStrict)(row, pk);
    }
    /**
     * 获取行唯一标识并标准化为**字符串**。
     *
     * 适用于：React key / Set / Map / DOM data-* / URL 参数等需要字符串身份的场景。
     * ⚠️ 会丢失原始类型信息，不要用于回传给业务方/服务端。
     */
    getRowKeyId(row, rowIndex) {
        const pk = this.primaryKey || primary_key_1.DEFAULT_PRIMARY_KEY;
        return (0, primary_key_1.getRowKeyId)(row, pk, rowIndex);
    }
    /**
     * 判断两个行 key 是否指向同一条 record。
     *
     * 规则：任一为 `null` / `undefined` 返回 `false`；否则按 `String(a) === String(b)` 比较。
     * 用于兼容上下游分别按 number / string 持有同一 id 的场景，避免历史宽松等价坑。
     */
    isSameRowKey(a, b) {
        return (0, primary_key_1.isSameRowKey)(a, b);
    }
    /** 设置数据操作 - 自动同步到所有视图，并重算公式列（派生值随源数据自动刷新） */
    setRawData(data) {
        this.rawData = this.applyFormulaCompute(data);
    }
    /**
     * 对传入数据批量重算所有公式列。
     * 公式是派生值，rawData 一旦被替换，必须根据当前 formulaConfig 重新生成，
     * 避免服务端原始数据覆盖掉公式结果。
     */
    applyFormulaCompute(data) {
        var _a;
        if (!Array.isArray(data) || data.length === 0)
            return data;
        const formulaConfig = (_a = this.customFields) === null || _a === void 0 ? void 0 : _a.formulaConfig;
        if (!formulaConfig || Object.keys(formulaConfig).length === 0)
            return data;
        const columnDefinitions = this.columnDefinitions || [];
        const fieldMap = this.fieldMap || {};
        const fields = columnDefinitions.map((col) => {
            var _a;
            return ({
                dataIndex: col.dataIndex,
                title: col.title || col.dataIndex,
                component: (_a = fieldMap[col.dataIndex]) === null || _a === void 0 ? void 0 : _a.component,
            });
        });
        return (0, formula_field_1.computeAllFormulaColumns)(formulaConfig, data, fields, columnDefinitions);
    }
    /** 设置原始列定义（从 props 传入） */
    setOriginColumns(columns) {
        // 转换 columns 格式，添加缺失的字段
        this.originColumns = (columns || []).map((col) => {
            var _a, _b;
            return ({
                // 保留原有字段
                dataIndex: col.dataIndex,
                title: col.title,
                format: col.format,
                hidden: (_a = col.hidden) !== null && _a !== void 0 ? _a : false,
                sortable: (_b = col.sortable) !== null && _b !== void 0 ? _b : false,
                getCellProps: col.getCellProps,
                // 新增字段
                code: col.dataIndex || col.title || '',
                copyTitle: col.title || '',
                cell: col.cell || col.render,
                render: col.render || col.cell,
            });
        });
    }
    /** 设置列定义(by 视图维度) */
    setColumnDefinitions(columns) {
        // 过滤掉 dataIndex 为空但有 columnCode 的列（这些是 AI 列，应该通过 mergeAiColumns 添加）
        const filteredColumns = columns.filter((col) => {
            if (!col.dataIndex && col.columnCode) {
                return false;
            }
            return true;
        });
        this.columnDefinitions = filteredColumns;
        const columnIds = columns.map((col) => col.dataIndex);
        // 更新字段信息
        this.viewConfigs.forEach((config, viewId) => {
            const currentColumnOrder = config.columnOrder || [];
            if (currentColumnOrder.length === 0) {
                // 如果 columnOrder 为空，使用所有传入列的 dataIndex(默认顺序排序)
                this.setViewConfig(viewId, {
                    columnOrder: columnIds,
                });
            }
        });
    }
    // 更新单元格 - 自动同步到所有视图
    updateCell(rowId, columnId, value) {
        const pk = this.primaryKey || primary_key_1.DEFAULT_PRIMARY_KEY;
        const rowIndex = this.rawData.findIndex((r, i) => {
            return (0, primary_key_1.safeGetRowKey)(r, pk, i) == rowId;
        });
        if (rowIndex !== -1) {
            const row = this.rawData[rowIndex];
            // 创建新对象以确保 MobX 能检测到变化
            const updatedRow = {
                ...row,
                [columnId]: value,
            };
            // 替换数组中的元素，触发 MobX 更新
            this.rawData[rowIndex] = updatedRow;
            // 重新赋值数组引用，确保视图更新
            this.rawData = [...this.rawData];
        }
    }
    // 更新行 - 自动同步到所有视图
    updateRow(rowId, row) {
        const pk = this.primaryKey || primary_key_1.DEFAULT_PRIMARY_KEY;
        const rowIndex = this.rawData.findIndex((r, i) => {
            return (0, primary_key_1.safeGetRowKey)(r, pk, i) == rowId;
        });
        if (rowIndex !== -1) {
            // 创建新对象以确保 MobX 能检测到变化
            // 替换数组中的元素，触发 MobX 更新
            this.rawData[rowIndex] = row;
            // 重新赋值数组引用，确保视图更新
            this.rawData = [...this.rawData];
        }
    }
    // 添加行
    addRow(row) {
        this.rawData.push(row);
        // 触发 MobX 更新
        this.rawData = [...this.rawData];
    }
    // 添加列
    addColumn(column) {
        const columnId = column === null || column === void 0 ? void 0 : column.dataIndex;
        if (columnId) {
            const existingIndex = this.columnDefinitions.findIndex((item) => item.dataIndex === columnId);
            if (existingIndex >= 0) {
                const nextColumns = [...this.columnDefinitions];
                nextColumns[existingIndex] = {
                    ...nextColumns[existingIndex],
                    ...column,
                };
                this.columnDefinitions = nextColumns;
            }
            else {
                this.columnDefinitions = [...this.columnDefinitions, column];
            }
        }
        else {
            this.columnDefinitions = [...this.columnDefinitions, column];
        }
        // 如果是 AI 列（有 aiConfig 属性），同时更新 aiColumns 数组
        if (column.aiConfig) {
            const aiColumn = {
                tableId: this.tableId,
                columnCode: column.dataIndex,
                columnName: column.title,
                scenarioId: column.aiConfig.scenarioId || constants_1.AGENT_ID,
                gatewayType: column.aiConfig.gatewayType || 'caibao',
                modelName: column.aiConfig.modelName || 'qwen-max',
                promptTemplate: column.aiConfig.promptTemplate || column.aiConfig.targetInfo || '',
            };
            // 检查是否已存在该列，避免重复添加
            const existingIndex = this.aiColumns.findIndex((col) => col.columnCode === aiColumn.columnCode);
            if (existingIndex >= 0) {
                // 更新已存在的 AI 列
                this.aiColumns[existingIndex] = aiColumn;
            }
            else {
                // 添加新的 AI 列
                this.aiColumns.push(aiColumn);
            }
            // 触发 MobX 更新
            this.aiColumns = [...this.aiColumns];
        }
    }
    // 删除行
    removeRow(rowId) {
        const pk = this.primaryKey || primary_key_1.DEFAULT_PRIMARY_KEY;
        const index = this.rawData.findIndex((r, i) => {
            return (0, primary_key_1.safeGetRowKey)(r, pk, i) == rowId;
        });
        if (index !== -1) {
            this.rawData.splice(index, 1);
            // 触发 MobX 更新
            this.rawData = [...this.rawData];
        }
    }
    // 视图配置管理
    getViewConfig(viewId) {
        if (!this.viewConfigs.has(viewId)) {
            // 如果视图不存在，不应该自动创建，而是返回一个临时配置
            // 这样可以避免意外创建视图导致 tab 中出现多余的切换项
            // 只有在明确调用 createView 时才应该创建新视图
            const defaultConfig = {
                id: viewId,
                name: viewId,
                type: 'Grid',
                hiddenColumns: [],
                filter: [],
                sort: [],
                group: [],
                aggregate: {},
                custom: {},
                colorFill: [],
                aiConfig: {},
                creator: '',
                createTime: Date.now(),
            };
            // 不将临时配置添加到 viewConfigs，避免出现在 tab 列表中
            return defaultConfig;
        }
        return this.viewConfigs.get(viewId);
    }
    // 更新视图配置
    // @param shouldPersist 是否立即持久化到远程服务器，默认为 false
    setViewConfig(viewId, config, shouldPersist = false) {
        // 只有在视图已存在时才更新，避免意外创建新视图
        if (!this.viewConfigs.has(viewId)) {
            console.warn(`视图 ${viewId} 不存在，无法更新配置`);
            return;
        }
        const current = this.viewConfigs.get(viewId);
        this.viewConfigs.set(viewId, { ...current, ...config });
        // 如果需要立即持久化，则调用持久化方法
        if (shouldPersist) {
            this.updateRemoteViews();
        }
    }
    // 设置当前活动视图
    setActiveView(viewId) {
        this.activeViewId = viewId;
    }
    // 获取视图过滤后的数据（自动缓存，通过 computed 实现）
    // 自动合并 AI 单元格数据层的数据
    getViewData(viewId) {
        const config = this.getViewConfig(viewId);
        // 先合并 AI 数据，再应用视图过滤
        const dataWithAi = this.getDisplayData();
        return this.applyViewFilters(dataWithAi, config);
    }
    /**
     * 设置视图的显示顺序数据
     * @description 由表格视图组件在数据变化时调用，更新当前视图的显示顺序数据
     * 这个数据考虑了分组/筛选/排序后的实际显示顺序
     * @param viewId - 视图ID
     * @param rows - 按显示顺序排列的数据行数组
     */
    setDisplayOrderData(viewId, rows) {
        this.displayOrderDataMap.set(viewId, rows);
    }
    /**
     * 获取视图的显示顺序数据
     * @description 获取当前视图页面实际显示的数据行顺序（考虑分组/筛选/排序）
     * 如果没有缓存，则回退到 getViewData（仅筛选，不考虑分组顺序）
     * @param viewId - 视图ID
     * @returns 按显示顺序排列的数据行数组
     */
    getDisplayOrderData(viewId) {
        const cachedData = this.displayOrderDataMap.get(viewId);
        if (cachedData && cachedData.length > 0) {
            return cachedData;
        }
        // 回退到 getViewData（仅筛选，不考虑分组顺序）
        return this.getViewData(viewId);
    }
    // 获取视图的列定义（根据 columnOrder 配置排序，然后过滤掉隐藏字段）
    // 改造后 AI 列与普通列在显隐逻辑上完全统一，都通过 hiddenColumns 控制
    getViewColumns(viewId) {
        var _a, _b;
        const config = this.getViewConfig(viewId);
        const { columnOrder, hiddenColumns } = config;
        // 创建 columnDefinitions 的映射，以 dataIndex 为 key
        const columnMap = new Map((_a = this.columnDefinitions) === null || _a === void 0 ? void 0 : _a.map((col) => [col.dataIndex, col]));
        // 表级已启用的 AI 列（用于判断 columnOrder 中的 AI 列是否有效）
        const customAiColumnSet = new Set(this.customFields.aiColumns);
        // 获取所有字段的 ID
        const allColumnIds = ((_b = this.columnDefinitions) === null || _b === void 0 ? void 0 : _b.map((col) => col.dataIndex)) || [];
        // 构建最终的字段顺序：
        // 1. 先按 columnOrder 中的顺序排列（如果存在）
        // 2. 然后追加不在 columnOrder 中但存在于 columnDefinitions 的字段
        let orderedColumnIds = [];
        // AI 列的全集（用于判断某列是否为 AI 列）
        const aiColumnFullSet = new Set(this.aiColumns.map((col) => col.columnCode));
        if (columnOrder && columnOrder.length > 0) {
            orderedColumnIds = columnOrder.filter((id) => columnMap.has(id) || customAiColumnSet.has(id));
            const columnOrderSet = new Set(columnOrder);
            const orderedColumnIdSet = new Set(orderedColumnIds);
            const newColumns = allColumnIds.filter((id) => {
                if (!id || columnOrderSet.has(id) || orderedColumnIdSet.has(id))
                    return false;
                // AI 列只有在 customFields.aiColumns 中才追加，避免未启用的 AI 列泄漏
                if (aiColumnFullSet.has(id))
                    return customAiColumnSet.has(id);
                return true;
            });
            orderedColumnIds = [...orderedColumnIds, ...newColumns];
        }
        else {
            // 没有 columnOrder 时同样过滤未启用的 AI 列
            orderedColumnIds = allColumnIds.filter((id) => {
                if (aiColumnFullSet.has(id))
                    return customAiColumnSet.has(id);
                return true;
            });
        }
        // 统一过滤：只通过 hiddenColumns 控制所有字段的可见性
        const hiddenSet = new Set(hiddenColumns || []);
        const visibleColumnIds = Array.from(new Set(orderedColumnIds)).filter((id) => !hiddenSet.has(id));
        // 根据过滤后的顺序，映射出列定义并添加可编辑性信息
        return visibleColumnIds
            .map((columnId) => {
            const col = columnMap.get(columnId);
            if (col) {
                return {
                    ...col,
                    editable: this.isFieldEditable(columnId),
                };
            }
            return undefined;
        })
            .filter((col) => col !== undefined);
    }
    getViewColumnMetaData(viewId) {
        var _a, _b;
        const config = this.getViewConfig(viewId);
        // 获取所有字段的 ID
        const allColumnIds = ((_a = this.columnDefinitions) === null || _a === void 0 ? void 0 : _a.map((col) => col.dataIndex)) || [];
        // 构建完整字段顺序：
        // 1. 先按 columnOrder 中的顺序排列（如果存在）
        // 2. 然后追加不在 columnOrder 中但存在于 columnDefinitions 的字段
        let fullOrder = [];
        if (config.columnOrder && config.columnOrder.length > 0) {
            // 创建 columnDefinitions 的映射，用于验证字段是否存在
            const columnMap = new Map((_b = this.columnDefinitions) === null || _b === void 0 ? void 0 : _b.map((col) => [col.dataIndex, col]));
            // 先添加 columnOrder 中存在的字段
            fullOrder = config.columnOrder.filter((id) => columnMap.has(id));
            // 找出不在 columnOrder 中的新字段
            const columnOrderSet = new Set(config.columnOrder);
            const newColumns = allColumnIds.filter((id) => !columnOrderSet.has(id));
            // 将新字段追加到末尾
            fullOrder = [...fullOrder, ...newColumns];
        }
        else {
            // 如果没有 columnOrder，使用所有 columnDefinitions 的顺序
            fullOrder = allColumnIds;
        }
        // 如果有 hiddenColumns，从完整字段顺序中过滤掉隐藏字段
        // 否则使用所有字段
        const columnIds = config.hiddenColumns && config.hiddenColumns.length > 0
            ? fullOrder.filter((id) => !config.hiddenColumns.includes(id))
            : fullOrder;
        const tableColumns = this.buildTableColumns(columnIds);
        return (0, get_column_meta_data_1.getColumnMetadata)(this.fieldMap, tableColumns);
    }
    // 创建新视图
    // @param type 视图类型
    // @param name 视图名称（可选）
    // @param initialConfig 初始配置（可选），用于复制视图时传入源视图的配置
    createView(type, name, initialConfig) {
        const viewId = (0, utils_1.generateViewId)();
        const viewName = name || this.getDefaultViewName(type);
        // 初始化时使用所有可用列的ID（如果列定义已存在）
        const initialColumnOrder = this.columnDefinitions.length > 0 ? this.columnDefinitions.map((col) => col.dataIndex) : [];
        const newView = (0, utils_1.getDefaultValueViews)({
            viewId,
            name: viewName,
            type,
            creator: '',
        });
        newView.columnOrder = initialColumnOrder;
        // 复制视图时只复制显隐/顺序/筛选等视图级配置，不复制 aiConfig/aiColumns（已在表级）
        if (initialConfig) {
            Object.assign(newView, {
                columnOrder: initialConfig.columnOrder || newView.columnOrder,
                hiddenColumns: initialConfig.hiddenColumns || newView.hiddenColumns,
                filter: initialConfig.filter || newView.filter,
                sort: initialConfig.sort || newView.sort,
                group: initialConfig.group || newView.group,
                aggregate: initialConfig.aggregate || newView.aggregate,
                custom: initialConfig.custom || newView.custom,
                colorFill: initialConfig.colorFill || newView.colorFill,
            });
        }
        this.viewConfigs.set(viewId, (0, view_config_normalizer_1.normalizeViewConfigForRuntime)(newView));
        // 将新视图添加到 viewOrder 末尾
        this.viewOrder = [...this.viewOrder, viewId];
        this.activeViewId = viewId;
        this.updateRemoteViews();
        return viewId;
    }
    /**
     * 把当前视图配置合成为 `ViewsData` 普通对象。
     * 与 `updateRemoteViews()` 内部的"清洗后持久化"快照独立——本方法返回未清洗的运行时原状，
     * 供运行时镜像 / 调试读取等只读消费。
     */
    toViewsDataSnapshot() {
        return {
            views: Object.fromEntries(this.viewConfigs),
            viewOrder: [...this.viewOrder],
            customFields: this.customFields,
        };
    }
    async updateRemoteViews() {
        var _a, _b, _c, _d, _e, _f;
        // 获取所有有效的列 ID（包括普通列和 AI 列）
        const validColumnIds = new Set(this.columnDefinitions.map((col) => col.dataIndex));
        // 获取所有有效的 AI 列 ID
        const validAiColumnIds = new Set(this.aiColumns.map((col) => col.columnCode));
        // 合并普通列和 AI 列，用于清理 hiddenColumns/columnOrder 中的无效引用
        const allValidColumnIds = new Set([...validColumnIds, ...validAiColumnIds]);
        const newViews = {};
        for (const [viewId, viewConfig] of this.viewConfigs) {
            // 清理视图配置中的无效列引用（已删除的列）
            const cleanedConfig = {
                ...viewConfig,
                columnOrder: (viewConfig.columnOrder || []).filter((id) => allValidColumnIds.has(id)),
                hiddenColumns: (viewConfig.hiddenColumns || []).filter((id) => allValidColumnIds.has(id)),
                filter: (viewConfig.filter || []).filter((rule) => !rule.field || validColumnIds.has(rule.field)),
                sort: (viewConfig.sort || []).filter((rule) => !rule.field || validColumnIds.has(rule.field)),
                group: (viewConfig.group || []).filter((rule) => !rule.field || validColumnIds.has(rule.field)),
                colorFill: (viewConfig.colorFill || []).filter((rule) => !rule.field || validColumnIds.has(rule.field)),
                aiConfig: viewConfig.aiConfig
                    ? Object.fromEntries(Object.entries(viewConfig.aiConfig).filter(([key]) => validColumnIds.has(key)))
                    : {},
            };
            newViews[viewId] = cleanedConfig;
        }
        // 双写：将表级 customFields 同步回各视图的 aiConfig/aiColumns（旧版兼容），SmartFollow 跳过
        for (const [, vc] of Object.entries(newViews)) {
            if (vc.type !== 'SmartFollow') {
                vc.aiConfig = { ...this.customFields.aiConfig };
                vc.aiColumns = [...this.customFields.aiColumns];
            }
        }
        // persist 归一化：按视图类型裁剪无效字段（SmartFollow 瘦身）
        for (const [vid, vc] of Object.entries(newViews)) {
            newViews[vid] = (0, view_config_normalizer_1.normalizeViewConfigForPersist)(vc);
        }
        // 保存时同时保存视图顺序和表级自定义字段
        const viewsData = {
            views: newViews,
            viewOrder: this.viewOrder,
            customFields: this.customFields,
        };
        const { _nodeId } = (0, hooks_1.getLowcodeConfig)();
        // 低码场景：有 _nodeId 时视图持久化固定走魔方
        if (_nodeId) {
            await ((_b = (_a = window.__CN_CUBE_INSTANCE__) === null || _a === void 0 ? void 0 : _a.__AI_Field_Fun__) === null || _b === void 0 ? void 0 : _b.setTableView({
                tableId: this.tableId,
                viewsData,
                nodeId: _nodeId,
            }));
            return;
        }
        if ((_d = (_c = this.bizRequestConfig) === null || _c === void 0 ? void 0 : _c.viewConfig) === null || _d === void 0 ? void 0 : _d.saveViewsUrl) {
            try {
                await (0, services_1.saveTableViews)({ tableId: this.tableId, viewsData }, this.bizRequestConfig);
            }
            catch {
                // 保存失败不阻断本地视图编辑
            }
            return;
        }
        // 仅配 query、未配 save（与业务「成对或都不配」约定不符）：不写远端，避免读写分叉
        if ((_f = (_e = this.bizRequestConfig) === null || _e === void 0 ? void 0 : _e.viewConfig) === null || _f === void 0 ? void 0 : _f.queryViewsUrl) {
            return;
        }
        // 源码未配业务视图 URL：直连魔方开放平台 createOrUpdate（与读侧 `fetchViewsFromCube` 一致）
        const meta = (0, services_1.getCubePlatformMeta)(this.tableId, this.bizRequestConfig);
        if (meta) {
            const r = await (0, services_1.persistViewsToCube)({
                meta,
                tableId: this.tableId,
                viewsData,
                userCubeConfigRowIdHint: this.cubePlatformUserConfigRowId || undefined,
                bizRequestConfig: this.bizRequestConfig,
            });
            if (r.success && r.userCubeConfigRowId) {
                this.cubePlatformUserConfigRowId = r.userCubeConfigRowId;
            }
        }
    }
    /**
     * @description 重置视图配置为初始默认值: 测试用的，不要在生产环境使用。
     * - AI 字段：逐个调用远程删除接口，再清理本地状态
     * - 公式字段：仅清理本地状态
     * - 视图配置：清空筛选、排序、分组、填色、隐藏列、冻结列等
     * 保留视图的身份信息（id、name、type）
     */
    async resetViewConfig(viewId) {
        if (!this.viewConfigs.has(viewId)) {
            console.warn(`视图 ${viewId} 不存在，无法重置配置`);
            return;
        }
        // ---- 1. 删除所有 AI 字段（需远程调用） ----
        const aiColumnCodes = [...this.customFields.aiColumns];
        for (const columnCode of aiColumnCodes) {
            try {
                if (this.tableId) {
                    const result = await (0, services_1.removeAiColumn)({ tableId: this.tableId, columnCode }, this.bizRequestConfig, {
                        userCubeConfigRowIdHint: this.cubePlatformUserConfigRowId || undefined,
                        onUserCubeConfigRowId: (id) => this.setCubePlatformUserConfigRowId(id),
                    });
                    if (!(result === null || result === void 0 ? void 0 : result.success)) {
                        console.warn(`删除 AI 列 ${columnCode} 失败:`, (result === null || result === void 0 ? void 0 : result.errorMsg) || (result === null || result === void 0 ? void 0 : result.msg));
                    }
                }
            }
            catch (e) {
                console.warn(`删除 AI 列 ${columnCode} 异常:`, e);
            }
            // 无论远程是否成功，都清理本地状态
            const newAiColumns = this.aiColumns.filter((col) => col.columnCode !== columnCode);
            this.setAiColumns(newAiColumns);
            this.removeFieldFromColumnDefinitions(columnCode);
            this.removeCustomField(columnCode);
        }
        // ---- 2. 删除所有公式字段（仅本地） ----
        const formulaCodes = Object.keys(this.customFields.formulaConfig);
        for (const columnCode of formulaCodes) {
            this.removeFieldFromColumnDefinitions(columnCode);
            this.removeCustomField(columnCode);
        }
        // ---- 3. 删除所有引用字段（仅本地） ----
        const lookupCodes = Object.keys(this.customFields.lookupConfig);
        for (const columnCode of lookupCodes) {
            this.removeFieldFromColumnDefinitions(columnCode);
            this.removeCustomField(columnCode);
        }
        // ---- 4. 清理所有视图配置中的 AI/公式/引用字段引用 ----
        const removedFieldIds = new Set([...aiColumnCodes, ...formulaCodes, ...lookupCodes]);
        this.viewConfigs.forEach((config, vid) => {
            this.setViewConfig(vid, {
                columnOrder: (config.columnOrder || []).filter((id) => !removedFieldIds.has(id)),
                hiddenColumns: (config.hiddenColumns || []).filter((id) => !removedFieldIds.has(id)),
                filter: (config.filter || []).filter((rule) => !removedFieldIds.has(rule.field)),
                sort: (config.sort || []).filter((rule) => !removedFieldIds.has(rule.field)),
                group: (config.group || []).filter((rule) => !removedFieldIds.has(rule.field)),
                colorFill: (config.colorFill || []).filter((rule) => !removedFieldIds.has(rule.field)),
            });
        });
        // ---- 5. 重置当前视图的用户配置为默认值 ----
        this.setViewConfig(viewId, {
            filter: [],
            sort: [],
            group: [],
            formulaConfig: {},
            colorFill: [],
            hiddenColumns: [],
            aggregate: {},
            custom: {},
        });
        // ---- 6. 清空 AI 单元格缓存 ----
        this.clearAiCellData();
        // ---- 7. 持久化 ----
        await this.updateRemoteViews();
    }
    /**
     * 从 columnDefinitions 中移除指定字段（不触发视图配置同步）
     */
    removeFieldFromColumnDefinitions(columnId) {
        this.columnDefinitions = this.columnDefinitions.filter((col) => col.dataIndex !== columnId);
    }
    // 删除视图
    deleteView(viewId) {
        if (!this.canDeleteView(viewId)) {
            return;
        }
        this.viewConfigs.delete(viewId);
        // 从 viewOrder 中移除
        this.viewOrder = this.viewOrder.filter((id) => id !== viewId);
        if (this.activeViewId === viewId) {
            // 如果删除的是当前活动视图，切换到 viewOrder 中的第一个视图
            this.activeViewId = this.viewOrder[0] || Array.from(this.viewConfigs.keys())[0] || null;
        }
        this.updateRemoteViews();
    }
    // 重新排序视图
    reorderViews(newViewIds) {
        // 同步更新 viewOrder
        this.viewOrder = newViewIds.filter((id) => this.viewConfigs.has(id));
        this.updateRemoteViews();
    }
    setAllViews(views, options) {
        const enableSmartFollow = (options === null || options === void 0 ? void 0 : options.enableSmartFollow) !== false;
        // 解析表级自定义字段配置（含历史数据迁移）
        this.resolveCustomFields(views);
        // 将公式列恢复到 columnDefinitions（类似 mergeAiColumns 对 AI 列的处理）
        this.mergeFormulaColumns();
        // 将引用字段恢复到 columnDefinitions
        this.mergeLookupColumns();
        const newViews = new Map();
        const viewOrder = views.viewOrder || [];
        // 按照 viewOrder 的顺序添加视图（runtime 归一化：清理 SmartFollow 历史脏数据）
        viewOrder.forEach((viewId) => {
            const viewConfig = views.views[viewId];
            if (viewConfig) {
                newViews.set(viewId, (0, view_config_normalizer_1.normalizeViewConfigForRuntime)(viewConfig));
            }
        });
        if (!enableSmartFollow) {
            Array.from(newViews.entries()).forEach(([id, cfg]) => {
                if (cfg.type === 'SmartFollow') {
                    newViews.delete(id);
                }
            });
        }
        // 查找或创建 Grid 视图
        let gridViewId = null;
        for (const [viewId, viewConfig] of newViews) {
            if (viewConfig.type === 'Grid') {
                gridViewId = viewId;
                break;
            }
        }
        if (!gridViewId) {
            const gridView = this.createDefaultViewConfig('Grid');
            gridViewId = gridView.id;
            newViews.set(gridViewId, gridView);
        }
        let smartFollowViewId = null;
        if (enableSmartFollow) {
            // 查找或创建 SmartFollow 视图
            for (const [viewId, viewConfig] of newViews) {
                if (viewConfig.type === 'SmartFollow') {
                    smartFollowViewId = viewId;
                    break;
                }
            }
            if (!smartFollowViewId) {
                const smartFollowView = this.createDefaultViewConfig('SmartFollow');
                smartFollowViewId = smartFollowView.id;
                newViews.set(smartFollowViewId, smartFollowView);
            }
        }
        // 构建最终的 viewOrder：Grid -> SmartFollow（可选）-> 其他视图
        const finalViewOrder = [gridViewId];
        if (smartFollowViewId) {
            finalViewOrder.push(smartFollowViewId);
        }
        // 添加其他视图
        viewOrder.forEach((viewId) => {
            if (viewId !== gridViewId && viewId !== smartFollowViewId && newViews.has(viewId)) {
                finalViewOrder.push(viewId);
            }
        });
        // 设置视图配置和顺序
        this.viewConfigs = newViews;
        this.viewOrder = finalViewOrder;
        // 激活第一个视图
        if (finalViewOrder[0]) {
            this.setActiveView(finalViewOrder[0]);
        }
        // 视图配置后到的时序场景：rawData 先于 customFields.formulaConfig 落位，
        // 此时它还没经过公式重算；这里在 formulaConfig 就绪后触发一次回填。
        if (this.rawData.length > 0) {
            this.rawData = this.applyFormulaCompute(this.rawData);
        }
    }
    // 获取所有视图列表（按 viewOrder 顺序返回）
    getAllViews() {
        // 如果 viewOrder 存在且有效，按顺序返回
        if (this.viewOrder.length > 0) {
            const orderedViews = [];
            this.viewOrder.forEach((viewId) => {
                const view = this.viewConfigs.get(viewId);
                if (view) {
                    orderedViews.push(view);
                }
            });
            // 添加 viewOrder 中没有但 viewConfigs 中存在的视图（兼容性处理）
            this.viewConfigs.forEach((view, viewId) => {
                if (!this.viewOrder.includes(viewId)) {
                    orderedViews.push(view);
                }
            });
            return orderedViews;
        }
        // 兼容旧数据：如果 viewOrder 为空，返回 Map 的默认顺序
        return Array.from(this.viewConfigs.values());
    }
    // 根据类型获取视图列表
    getViewsByType(type) {
        return Array.from(this.viewConfigs.values()).filter((view) => view.type === type);
    }
    setFieldMap(fieldMap) {
        this.fieldMap = fieldMap;
    }
    getFieldItem(key) {
        return this.fieldMap[key];
    }
    // 设置表格选择信息
    setSelectionInfo(selectKeys, storeSelectInfo, showSelectedNum = false) {
        this.selectKeys = selectKeys;
        this.storeSelectInfo = storeSelectInfo;
        this.showSelectedNum = showSelectedNum;
    }
    setSelectedCountInCurrentView(count) {
        this.selectedCountInCurrentView = count;
    }
    /** 设置是否支持批量编辑 */
    setSupportBatchEdit(support) {
        this.supportBatchEdit = support;
    }
    setBizRequestConfig(config) {
        this.bizRequestConfig = config;
    }
    setLookupFieldConfig(config) {
        this.lookupFieldConfig = config;
    }
    setGridToolbarPermissions(permissions) {
        this.gridToolbarPermissions = permissions;
    }
    setHideColumnHeaderMenu(hide) {
        this.hideColumnHeaderMenu = hide;
    }
    // 判断字段是否可编辑
    isFieldEditable(columnId) {
        // AI 列始终可编辑，无论是专业版还是鸟搭场景
        if (this.isAiColumn(columnId)) {
            return true;
        }
        // 未开启批量编辑时，普通字段不可编辑
        if (!this.supportBatchEdit) {
            return false;
        }
        // 如果字段在 fieldMap 中存在，则是可编辑的
        return this.fieldMap && this.fieldMap[columnId] !== undefined;
    }
    getFieldMap() {
        return this.fieldMap;
    }
    // ==================== 表级自定义字段方法 ====================
    /**
     * 从 ViewsData 解析 customFields，处理历史数据迁移
     * 幂等：如果 customFields 已存在则直接使用，不再从视图级合并
     */
    resolveCustomFields(viewsData) {
        var _a;
        if (viewsData.customFields &&
            (Object.keys(viewsData.customFields.aiConfig).length > 0 ||
                viewsData.customFields.aiColumns.length > 0 ||
                Object.keys(viewsData.customFields.formulaConfig).length > 0 ||
                Object.keys(viewsData.customFields.lookupConfig || {}).length > 0)) {
            this.customFields = {
                ...viewsData.customFields,
                lookupConfig: viewsData.customFields.lookupConfig || {},
            };
            return;
        }
        // 历史数据迁移：从所有视图收集并合并
        const mergedAiConfig = {};
        const mergedAiColumnsSet = new Set();
        const mergedFormulaConfig = {};
        const orderedViewIds = ((_a = viewsData.viewOrder) === null || _a === void 0 ? void 0 : _a.length)
            ? viewsData.viewOrder
            : Object.keys(viewsData.views);
        orderedViewIds.forEach((viewId) => {
            const vc = viewsData.views[viewId];
            if (!vc)
                return;
            // 合并 aiConfig（同 columnCode 取第一个视图的配置）
            if (vc.aiConfig) {
                Object.entries(vc.aiConfig).forEach(([key, val]) => {
                    if (!mergedAiConfig[key]) {
                        mergedAiConfig[key] = val;
                    }
                });
            }
            // 合并 aiColumns
            if (vc.aiColumns) {
                vc.aiColumns.forEach((code) => mergedAiColumnsSet.add(code));
            }
            // 合并 formulaConfig
            if (vc.formulaConfig) {
                Object.entries(vc.formulaConfig).forEach(([key, val]) => {
                    if (!mergedFormulaConfig[key]) {
                        mergedFormulaConfig[key] = val;
                    }
                });
            }
        });
        this.customFields = {
            aiConfig: mergedAiConfig,
            aiColumns: Array.from(mergedAiColumnsSet),
            formulaConfig: mergedFormulaConfig,
            lookupConfig: {},
        };
        // 自动填充 hiddenColumns：对于历史数据中某视图没有启用某 AI/公式字段的情况
        orderedViewIds.forEach((viewId) => {
            const vc = viewsData.views[viewId];
            if (!vc)
                return;
            const oldAiColumns = new Set(vc.aiColumns || []);
            const oldFormulaKeys = new Set(Object.keys(vc.formulaConfig || {}));
            const currentHidden = new Set(vc.hiddenColumns || []);
            // AI 字段：如果旧视图没有该 AI 列，则加入 hiddenColumns
            this.customFields.aiColumns.forEach((code) => {
                if (!oldAiColumns.has(code) && !currentHidden.has(code)) {
                    currentHidden.add(code);
                }
            });
            // 公式字段：如果旧视图没有该公式列，则加入 hiddenColumns
            Object.keys(this.customFields.formulaConfig).forEach((code) => {
                if (!oldFormulaKeys.has(code) && !currentHidden.has(code)) {
                    currentHidden.add(code);
                }
            });
            vc.hiddenColumns = Array.from(currentHidden);
        });
    }
    /** 获取表级 AI 字段配置 */
    getCustomFieldAiConfig(columnCode) {
        return this.customFields.aiConfig[columnCode];
    }
    /** 写入表级 AI 字段配置 */
    setCustomFieldAiConfig(columnCode, config) {
        this.customFields = {
            ...this.customFields,
            aiConfig: { ...this.customFields.aiConfig, [columnCode]: config },
            aiColumns: this.customFields.aiColumns.includes(columnCode)
                ? this.customFields.aiColumns
                : [...this.customFields.aiColumns, columnCode],
        };
    }
    /** 从表级配置中移除自定义字段 */
    removeCustomField(columnCode) {
        const { [columnCode]: _ai, ...restAiConfig } = this.customFields.aiConfig;
        const { [columnCode]: _formula, ...restFormulaConfig } = this.customFields.formulaConfig;
        const { [columnCode]: _lookup, ...restLookupConfig } = this.customFields.lookupConfig;
        this.customFields = {
            aiConfig: restAiConfig,
            aiColumns: this.customFields.aiColumns.filter((c) => c !== columnCode),
            formulaConfig: restFormulaConfig,
            lookupConfig: restLookupConfig,
        };
    }
    /** 获取表级公式字段配置 */
    getCustomFieldFormulaConfig(columnCode) {
        return this.customFields.formulaConfig[columnCode];
    }
    /** 写入表级公式字段配置 */
    setCustomFieldFormulaConfig(columnCode, config) {
        this.customFields = {
            ...this.customFields,
            formulaConfig: { ...this.customFields.formulaConfig, [columnCode]: config },
        };
    }
    /** 获取表级引用字段配置 */
    getCustomFieldLookupConfig(columnCode) {
        return this.customFields.lookupConfig[columnCode];
    }
    /** 写入表级引用字段配置 */
    setCustomFieldLookupConfig(columnCode, config) {
        this.customFields = {
            ...this.customFields,
            lookupConfig: { ...this.customFields.lookupConfig, [columnCode]: config },
        };
    }
    // ==================== AI 列相关方法 ====================
    /**
     * 设置 AI 列列表
     */
    setAiColumns(columns) {
        this.aiColumns = columns;
    }
    /**
     * 获取 AI 列列表
     */
    getAiColumns() {
        return this.aiColumns;
    }
    /**
     * 将 AI 列合并到全局列定义中（不自动同步到视图）
     * @param aiColumns AI 列列表
     * @param shouldPersist 是否持久化到远程
     */
    mergeAiColumns(aiColumns, shouldPersist = false) {
        if (!aiColumns || aiColumns.length === 0) {
            return;
        }
        // 创建列定义映射表，便于快速查找
        const columnDefMap = new Map((this.columnDefinitions || []).map((col) => [col.dataIndex, col]));
        // 存储转换后的 AI 列（用于 this.aiColumns）
        const transformedAiColumns = [];
        // 一次遍历完成所有转换和更新
        aiColumns.forEach((aiCol) => {
            const { columnCode, columnName } = aiCol;
            const aiColumnDef = this.createOrUpdateAiColumnDef(aiCol);
            // 转换为 aiColumns 格式（保留原始字段，添加 column 格式字段）
            transformedAiColumns.push({
                ...aiCol,
                title: columnName,
                dataIndex: columnCode,
                accessorKey: columnCode,
            });
            // 更新或添加到 columnDefinitions
            if (columnDefMap.has(columnCode)) {
                // 更新已存在的列
                columnDefMap.set(columnCode, {
                    ...columnDefMap.get(columnCode),
                    ...aiColumnDef,
                });
            }
            else {
                // 添加新列到全局定义池
                columnDefMap.set(columnCode, aiColumnDef);
            }
        });
        // 更新 aiColumns 和 columnDefinitions
        this.aiColumns = transformedAiColumns;
        this.columnDefinitions = Array.from(columnDefMap.values()); // 全量（包含ai字段）
        if (shouldPersist) {
            this.updateRemoteViews();
        }
    }
    /**
     * 将公式列合并到全局列定义中（从 customFields.formulaConfig 恢复）
     * 页面加载时调用，确保公式列在 columnDefinitions 中存在
     */
    mergeFormulaColumns() {
        var _a;
        const formulaConfig = (_a = this.customFields) === null || _a === void 0 ? void 0 : _a.formulaConfig;
        if (!formulaConfig || Object.keys(formulaConfig).length === 0) {
            return;
        }
        const columnDefMap = new Map((this.columnDefinitions || []).map((col) => [col.dataIndex, col]));
        let changed = false;
        Object.entries(formulaConfig).forEach(([columnCode, config]) => {
            if (!columnDefMap.has(columnCode)) {
                columnDefMap.set(columnCode, {
                    dataIndex: columnCode,
                    title: config.fieldName,
                    header: config.fieldName,
                    accessorKey: columnCode,
                    format: 'formula',
                });
                changed = true;
            }
        });
        if (changed) {
            this.columnDefinitions = Array.from(columnDefMap.values());
        }
    }
    /**
     * 将引用字段合并到全局列定义中（从 customFields.lookupConfig 恢复）
     * 页面加载时调用，确保引用字段列在 columnDefinitions 中存在
     */
    mergeLookupColumns() {
        var _a;
        const lookupConfig = (_a = this.customFields) === null || _a === void 0 ? void 0 : _a.lookupConfig;
        if (!lookupConfig || Object.keys(lookupConfig).length === 0) {
            return;
        }
        const columnDefMap = new Map((this.columnDefinitions || []).map((col) => [col.dataIndex, col]));
        let changed = false;
        Object.entries(lookupConfig).forEach(([columnCode, config]) => {
            if (!columnDefMap.has(columnCode)) {
                columnDefMap.set(columnCode, {
                    dataIndex: columnCode,
                    title: config.fieldName,
                    header: config.fieldName,
                    accessorKey: columnCode,
                    format: 'lookup',
                });
                changed = true;
            }
        });
        if (changed) {
            this.columnDefinitions = Array.from(columnDefMap.values());
        }
    }
    /**
     * 判断是否为 AI 列
     */
    isAiColumn(columnId) {
        return this.aiColumns.some((col) => col.columnCode === columnId);
    }
    /**
     * 获取 AI 列配置
     */
    getAiColumnConfig(columnId) {
        return this.aiColumns.find((col) => col.columnCode === columnId);
    }
    // ==================== 视图级别的 AI 列管理方法 ====================
    /**
     * 添加 AI 列到指定视图
     * 改造后：添加到表级 customFields.aiColumns + 各视图 columnOrder，确保该视图可见
     */
    addAiColumnToView(viewId, columnCode, shouldPersist = true) {
        const config = this.getViewConfig(viewId);
        if (!config)
            return;
        if (!this.isAiColumn(columnCode)) {
            console.warn(`AI 列 ${columnCode} 不存在于全局 AI 列定义中`);
            return;
        }
        // 添加到表级 customFields.aiColumns
        if (!this.customFields.aiColumns.includes(columnCode)) {
            this.customFields = {
                ...this.customFields,
                aiColumns: [...this.customFields.aiColumns, columnCode],
            };
        }
        // 添加到视图 columnOrder，确保不在 hiddenColumns 中
        const currentColumnOrder = config.columnOrder || [];
        const newColumnOrder = currentColumnOrder.includes(columnCode)
            ? currentColumnOrder
            : [...currentColumnOrder, columnCode];
        const currentHidden = config.hiddenColumns || [];
        const newHidden = currentHidden.filter((c) => c !== columnCode);
        this.setViewConfig(viewId, {
            columnOrder: newColumnOrder,
            hiddenColumns: newHidden,
        });
        if (shouldPersist) {
            this.updateRemoteViews();
        }
    }
    /**
     * 从指定视图移除 AI 列（仅隐藏，不从表级移除）
     */
    removeAiColumnFromView(viewId, columnCode, shouldPersist = true) {
        const config = this.getViewConfig(viewId);
        if (!config)
            return;
        const currentHiddenColumns = config.hiddenColumns || [];
        if (currentHiddenColumns.includes(columnCode))
            return;
        this.setViewConfig(viewId, {
            hiddenColumns: [...currentHiddenColumns, columnCode],
        });
        if (shouldPersist) {
            this.updateRemoteViews();
        }
    }
    /**
     * 批量添加 AI 列到指定视图
     */
    addAiColumnsToView(viewId, columnCodes, shouldPersist = true) {
        const config = this.getViewConfig(viewId);
        if (!config)
            return;
        const validColumnCodes = columnCodes.filter((code) => this.isAiColumn(code));
        if (validColumnCodes.length === 0)
            return;
        // 添加到表级 customFields.aiColumns
        const newTableAiColumns = Array.from(new Set([...this.customFields.aiColumns, ...validColumnCodes]));
        this.customFields = {
            ...this.customFields,
            aiColumns: newTableAiColumns,
        };
        // 添加到视图 columnOrder，从 hiddenColumns 中移除
        const currentColumnOrder = config.columnOrder || [];
        const missingCodes = validColumnCodes.filter((code) => !currentColumnOrder.includes(code));
        const newColumnOrder = missingCodes.length > 0 ? [...currentColumnOrder, ...missingCodes] : currentColumnOrder;
        const currentHidden = config.hiddenColumns || [];
        const codeSet = new Set(validColumnCodes);
        const newHidden = currentHidden.filter((c) => !codeSet.has(c));
        this.setViewConfig(viewId, {
            columnOrder: newColumnOrder,
            hiddenColumns: newHidden,
        });
        if (shouldPersist) {
            this.updateRemoteViews();
        }
    }
    /**
     * 获取视图中可见的 AI 列（不在 hiddenColumns 中的表级 AI 列）
     */
    getViewAiColumns(viewId) {
        const config = this.getViewConfig(viewId);
        const hiddenSet = new Set((config === null || config === void 0 ? void 0 : config.hiddenColumns) || []);
        return this.customFields.aiColumns.filter((code) => !hiddenSet.has(code));
    }
    /**
     * 判断视图是否启用了指定的 AI 列
     */
    isAiColumnEnabledInView(viewId, columnCode) {
        const config = this.getViewConfig(viewId);
        const hiddenSet = new Set((config === null || config === void 0 ? void 0 : config.hiddenColumns) || []);
        return this.customFields.aiColumns.includes(columnCode) && !hiddenSet.has(columnCode);
    }
    /**
     * 设置运行中的任务列表
     */
    setRunningTasks(tasks) {
        this.runningTasks = tasks;
    }
    /**
     * 判断某个单元格的任务是否正在运行
     */
    isTaskRunning(columnId, rowId) {
        return this.runningTasks.some((task) => task.columnCode === columnId && task.rowId === rowId);
    }
    /**
     * 添加单个运行中的任务
     */
    addRunningTask(columnCode, rowId) {
        // 避免重复添加
        if (!this.isTaskRunning(columnCode, rowId)) {
            this.runningTasks = [...this.runningTasks, { columnCode, rowId }];
        }
    }
    /**
     * 移除单个运行中的任务
     */
    removeRunningTask(columnCode, rowId) {
        this.runningTasks = this.runningTasks.filter((task) => !(task.columnCode === columnCode && task.rowId === rowId));
    }
    // ==================== AI 单元格数据层方法 ====================
    /**
     * 设置单个 AI 单元格数据
     * @param rowId 行 ID
     * @param columnCode 列编码
     * @param value 单元格值
     */
    setAiCellData(rowId, columnCode, value) {
        const key = this.getAiCellKey(rowId, columnCode);
        this.aiCellData.set(key, value);
        // 触发 MobX 更新（创建新的 Map 引用）
        this.aiCellData = new Map(this.aiCellData);
    }
    /**
     * 获取单个 AI 单元格数据
     * @param rowId 行 ID
     * @param columnCode 列编码
     * @returns 单元格值，如果不存在返回 undefined
     */
    getAiCellValue(rowId, columnCode) {
        const key = this.getAiCellKey(rowId, columnCode);
        return this.aiCellData.get(key);
    }
    /**
     * 批量合并 AI 任务结果到 AI 单元格数据层
     * @param taskResults 任务结果数组
     */
    mergeAiTaskResults(taskResults) {
        if (!(taskResults === null || taskResults === void 0 ? void 0 : taskResults.length))
            return;
        // 批量更新 aiCellData
        taskResults.forEach((task) => {
            if (task.rowId && task.columnCode && task.jobOutput !== undefined) {
                const key = this.getAiCellKey(task.rowId, task.columnCode);
                this.aiCellData.set(key, task.jobOutput);
            }
        });
        // 只触发一次 MobX 更新
        this.aiCellData = new Map(this.aiCellData);
    }
    /**
     * 清除所有 AI 单元格数据
     */
    clearAiCellData() {
        this.aiCellData = new Map();
    }
    /**
     * 清除指定列的 AI 单元格数据
     * @param columnCode 列编码
     */
    clearAiColumnCellData(columnCode) {
        const newMap = new Map(this.aiCellData);
        for (const key of newMap.keys()) {
            if (key.endsWith(`-${columnCode}`)) {
                newMap.delete(key);
            }
        }
        this.aiCellData = newMap;
    }
    /**
     * 获取带有 AI 数据的行（将 AI 单元格数据合并到原始行数据中）
     * @param row 原始行数据
     * @returns 合并了 AI 数据的行
     */
    getDisplayRow(row) {
        if (!row)
            return row;
        const rowId = this.getRowKey(row);
        if (!rowId)
            return row;
        // 检查该行是否有 AI 单元格数据
        let hasAiData = false;
        const aiData = {};
        this.aiColumns.forEach((col) => {
            const key = this.getAiCellKey(rowId, col.columnCode);
            if (this.aiCellData.has(key)) {
                hasAiData = true;
                aiData[col.columnCode] = this.aiCellData.get(key);
            }
        });
        // 如果没有 AI 数据，直接返回原始行
        if (!hasAiData)
            return row;
        // 合并 AI 数据到行中
        return { ...row, ...aiData };
    }
    /**
     * 获取带有 AI 数据的完整数据集
     * @returns 合并了 AI 数据的数据数组
     */
    getDisplayData() {
        return this.rawData.map((row) => this.getDisplayRow(row));
    }
    /**
     * 判断是否为主视图（第一个 Grid 视图）
     * 主视图不能被删除，不能被拖拽
     * @param viewId 视图 ID
     * @returns 是否为主视图
     */
    isPrimaryView(viewId) {
        const viewConfig = this.viewConfigs.get(viewId);
        if (!viewConfig || viewConfig.type !== 'Grid') {
            return false;
        }
        // 找到第一个 Grid 视图
        for (const id of this.viewOrder) {
            const config = this.viewConfigs.get(id);
            if ((config === null || config === void 0 ? void 0 : config.type) === 'Grid') {
                return id === viewId;
            }
        }
        return false;
    }
    /**
     * 判断视图是否可以被删除
     * 主视图和 SmartFollow 视图不能被删除
     * @param viewId 视图 ID
     * @returns 是否可以删除
     */
    canDeleteView(viewId) {
        const viewConfig = this.viewConfigs.get(viewId);
        if (!viewConfig) {
            return false;
        }
        // SmartFollow 视图不能删除
        if (viewConfig.type === 'SmartFollow') {
            return false;
        }
        // 主视图不能删除
        if (this.isPrimaryView(viewId)) {
            return false;
        }
        // 至少保留一个视图
        if (this.viewConfigs.size <= 1) {
            return false;
        }
        return true;
    }
    /**
     * 判断视图是否可以被拖拽
     * 主视图和 SmartFollow 视图不能被拖拽
     * @param viewId 视图 ID
     * @returns 是否可以拖拽
     */
    canDragView(viewId) {
        const viewConfig = this.viewConfigs.get(viewId);
        if (!viewConfig) {
            return false;
        }
        // SmartFollow 视图不能拖拽
        if (viewConfig.type === 'SmartFollow') {
            return false;
        }
        // 主视图不能拖拽
        if (this.isPrimaryView(viewId)) {
            return false;
        }
        return true;
    }
    /**
     * 创建 / 修改  AI 列定义对象
     * @param aiCol AI 列数据
     * @returns 列定义对象
     */
    createOrUpdateAiColumnDef(aiCol) {
        const { columnCode, columnName, scenarioId, promptTemplate } = aiCol;
        return {
            dataIndex: columnCode,
            title: columnName,
            accessorKey: columnCode,
            isAiColumn: true,
            format: 'ai-generate', // AI 字段使用专门的格式化（空值显示空而不是 "- -"）
            aiConfig: {
                scenarioId: scenarioId || constants_1.AGENT_ID,
                promptTemplate,
            },
            header: react_1.default.createElement('span', { style: { display: 'flex', alignItems: 'center', gap: '6px' } }, react_1.default.createElement('img', {
                src: field_types_1.AI_FIELD_ICON_URL,
                alt: i18n_1.default.get({ id: 'AIField', dm: 'AI字段' }),
                style: { width: '16px', height: '16px' },
            }), columnName),
        };
    }
    /**
     * 创建默认视图配置
     * @param type 视图类型
     * @returns 视图配置对象
     */
    createDefaultViewConfig(type) {
        const viewId = (0, utils_1.generateViewId)();
        const initialColumnOrder = this.columnDefinitions.length > 0 ? this.columnDefinitions.map((col) => col.dataIndex) : [];
        const nameMap = {
            Grid: i18n_1.default.get({ id: 'Table', dm: '表格' }),
            SmartFollow: i18n_1.default.get({ id: 'SmartMerchandiser', dm: '智能跟单' }),
        };
        const base = {
            id: viewId,
            name: nameMap[type],
            type,
            columnOrder: initialColumnOrder,
            hiddenColumns: [],
            filter: [],
            sort: [],
            group: [],
            aggregate: {},
            custom: {},
            creator: '',
            colorFill: [],
            createTime: Date.now(),
        };
        return (0, view_config_normalizer_1.normalizeViewConfigForRuntime)(base);
    }
    // 初始化默认视图配置（默认有 Grid 和 SmartFollow 两个视图）
    initDefaultViews() {
        const gridView = this.createDefaultViewConfig('Grid');
        const smartFollowView = this.createDefaultViewConfig('SmartFollow');
        this.viewConfigs.set(gridView.id, gridView);
        this.viewConfigs.set(smartFollowView.id, smartFollowView);
        // 初始化 viewOrder（Grid 在前，SmartFollow 在后）
        this.viewOrder = [gridView.id, smartFollowView.id];
        this.activeViewId = gridView.id;
    }
    // 获取默认视图名称
    getDefaultViewName(type) {
        const nameMap = {
            Grid: i18n_1.default.get({ id: 'Table', dm: '表格' }),
            Task: i18n_1.default.get({ id: 'Task', dm: '任务' }),
            SmartFollow: i18n_1.default.get({ id: 'SmartMerchandiser', dm: '智能跟单' }),
        };
        return nameMap[type] || i18n_1.default.get({ id: 'NewView', dm: '新视图' });
    }
    /**
     * 生成 AI 单元格数据的 key
     */
    getAiCellKey(rowId, columnCode) {
        return `${rowId}-${columnCode}`;
    }
    // 应用视图筛选、排序、分组
    applyViewFilters(data, config) {
        let result = [...data];
        // 应用筛选
        if (config.filter && config.filter.length > 0) {
            result = this.applyFilters(result, config.filter);
        }
        // 应用排序
        if (config.sort && config.sort.length > 0) {
            result = this.applySorting(result, config.sort);
        }
        // 注意：分组逻辑应该在表格组件中处理，因为分组需要表格实例支持
        // 这里只返回数据，分组由表格的 getGroupedRowModel 处理
        return result;
    }
    // 应用筛选条件（委托给筛选模块纯函数，与表格视图逻辑一致）
    applyFilters(data, filters) {
        return (0, customFilterFns_1.applyFiltersToData)(data, filters, this.fieldMap);
    }
    // 应用排序规则
    applySorting(data, sortRules) {
        if (sortRules.length === 0)
            return data;
        return [...data].sort((a, b) => {
            // 按照排序规则的顺序依次比较
            for (const sortRule of sortRules) {
                const rule = sortRule;
                if (rule.field) {
                    const aValue = a[rule.field];
                    const bValue = b[rule.field];
                    const order = rule.order === 'desc' ? -1 : 1;
                    // 如果当前字段值不相等，返回比较结果
                    let compareResult = 0;
                    // 处理 null/undefined 的情况
                    if (aValue == null && bValue == null) {
                        compareResult = 0;
                    }
                    else if (aValue == null) {
                        compareResult = 1; // null/undefined 排在后面
                    }
                    else if (bValue == null) {
                        compareResult = -1; // null/undefined 排在后面
                    }
                    else if (typeof aValue === 'string' && typeof bValue === 'string') {
                        // 如果两个值都是字符串，使用 localeCompare 进行本地化比较（支持中文拼音排序）
                        compareResult = aValue.localeCompare(bValue, 'zh-CN', {
                            numeric: true,
                            sensitivity: 'base',
                        });
                    }
                    else if (aValue < bValue) {
                        // 对于其他类型（数字、日期等），使用默认比较
                        compareResult = -1;
                    }
                    else if (aValue > bValue) {
                        compareResult = 1;
                    }
                    else {
                        compareResult = 0;
                    }
                    if (compareResult !== 0) {
                        return compareResult * order;
                    }
                    // 如果相等，继续比较下一个字段
                }
            }
            // 所有字段都相等，返回0
            return 0;
        });
    }
    /**
     * 根据字段ID列表生成 tableColumns
     * @param columnIds 字段ID数组
     * @returns 符合 getColumnMetadata 要求的格式
     */
    buildTableColumns(columnIds) {
        var _a;
        const columnMap = new Map((_a = this.columnDefinitions) === null || _a === void 0 ? void 0 : _a.map((col) => [col.dataIndex, col]));
        return columnIds === null || columnIds === void 0 ? void 0 : columnIds.map((id) => columnMap.get(id)).filter((col) => col !== undefined);
    }
}
exports.DataModel = DataModel;
