import $i18n from '../../../../../../locales/i18n.js';
/**
 * 列头菜单工具函数
 * 统一管理列头右键菜单相关的工具函数
 */
import { removeAiColumn } from '../../../../../../cn-ai-table/view/services';
import { getFieldSystem } from '../../../../../../cn-ai-table/view/field-system';
/**
 * 处理排序：正序
 * @param columnId 列ID
 * @param viewId 视图ID
 * @param dataModel 数据模型
 * @param setSelectedColumnId 设置选中列ID的函数
 * @param onShowSortPanel 可选的回调函数，用于显示排序面板
 */
export function handleSortAsc(columnId, viewId, dataModel, setSelectedColumnId, onShowSortPanel) {
    const viewConfig = dataModel.getViewConfig(viewId);
    const currentSort = viewConfig.sort || [];
    const newSort = [
        ...currentSort.filter((rule) => rule.field !== columnId),
        { field: columnId, order: 'asc' },
    ];
    dataModel.setViewConfig(viewId, {
        sort: newSort,
    });
    // 选中该列
    setSelectedColumnId(columnId);
    // 触发显示排序面板
    if (onShowSortPanel) {
        setTimeout(() => {
            onShowSortPanel();
        }, 0);
    }
}
/**
 * 处理排序：倒序
 * @param columnId 列ID
 * @param viewId 视图ID
 * @param dataModel 数据模型
 * @param setSelectedColumnId 设置选中列ID的函数
 * @param onShowSortPanel 可选的回调函数，用于显示排序面板
 */
export function handleSortDesc(columnId, viewId, dataModel, setSelectedColumnId, onShowSortPanel) {
    const viewConfig = dataModel.getViewConfig(viewId);
    const currentSort = viewConfig.sort || [];
    const newSort = [
        ...currentSort.filter((rule) => rule.field !== columnId),
        { field: columnId, order: 'desc' },
    ];
    dataModel.setViewConfig(viewId, {
        sort: newSort,
    });
    // 选中该列
    setSelectedColumnId(columnId);
    // 触发显示排序面板
    if (onShowSortPanel) {
        setTimeout(() => {
            onShowSortPanel();
        }, 0);
    }
}
/**
 * 处理整列填色
 * @param columnId 列ID
 * @param viewId 视图ID
 * @param dataModel 数据模型
 * @param setSelectedColumnId 设置选中列ID的函数
 * @param onShowColorFillPanel 可选的回调函数，用于显示填色面板
 */
export function handleFillColor(columnId, viewId, dataModel, setSelectedColumnId, onShowColorFillPanel) {
    const viewConfig = dataModel.getViewConfig(viewId);
    const currentColorFill = viewConfig.colorFill || [];
    // 检查是否已经存在该列的整列填色规则
    const existingRuleIndex = currentColorFill.findIndex((rule) => rule.field === columnId && rule.scope === 'column');
    // 默认颜色：使用预设颜色中的第一个浅色
    const defaultColor = 'rgba(255, 247, 230, 0.5)';
    let newColorFill;
    const isAddingNewRule = existingRuleIndex < 0;
    if (existingRuleIndex >= 0) {
        // 如果已存在，移除该规则（取消填色）
        newColorFill = currentColorFill.filter((_, index) => index !== existingRuleIndex);
    }
    else {
        // 如果不存在，添加新的整列填色规则
        const newRule = {
            field: columnId,
            operator: 'notEmpty', // 整列模式使用默认操作符
            value: '', // 整列模式不需要值
            color: defaultColor,
            scope: 'column',
        };
        newColorFill = [...currentColorFill, newRule];
    }
    // 更新填色配置
    dataModel.setViewConfig(viewId, {
        colorFill: newColorFill,
    });
    // 选中该列
    setSelectedColumnId(columnId);
    // 如果是添加新规则，触发显示填色面板
    if (isAddingNewRule && onShowColorFillPanel) {
        setTimeout(() => {
            onShowColorFillPanel();
        }, 0);
    }
}
/**
 * 处理按字段分组
 * @param columnId 列ID
 * @param viewId 视图ID
 * @param dataModel 数据模型
 * @param setSelectedColumnId 设置选中列ID的函数
 * @param onShowGroupPanel 可选的回调函数，用于显示分组面板
 */
export function handleGroupBy(columnId, viewId, dataModel, setSelectedColumnId, onShowGroupPanel) {
    const viewConfig = dataModel.getViewConfig(viewId);
    const currentGroup = viewConfig.group || [];
    // 检查是否已经存在该字段的分组规则
    const existingGroupIndex = currentGroup.findIndex((group) => group.field === columnId);
    let newGroup;
    const isAddingNewGroup = existingGroupIndex < 0;
    if (existingGroupIndex >= 0) {
        // 如果已存在，移除该规则（取消分组）
        newGroup = currentGroup.filter((_, index) => index !== existingGroupIndex);
    }
    else {
        // 如果不存在，添加新的分组规则
        // 如果已有分组，追加到末尾；否则创建新的分组数组
        newGroup = [...currentGroup, { field: columnId }];
    }
    // 更新分组配置
    dataModel.setViewConfig(viewId, {
        group: newGroup,
    });
    // 选中该列
    setSelectedColumnId(columnId);
    // 如果是添加新分组，触发显示分组面板
    if (isAddingNewGroup && onShowGroupPanel) {
        setTimeout(() => {
            onShowGroupPanel();
        }, 0);
    }
}
/**
 * 处理按字段筛选
 * @param columnId 列ID
 * @param viewId 视图ID
 * @param dataModel 数据模型
 * @param setSelectedColumnId 设置选中列ID的函数
 * @param onShowFilterPanel 可选的回调函数，用于显示筛选面板
 */
export function handleFilterBy(columnId, viewId, dataModel, setSelectedColumnId, onShowFilterPanel) {
    const viewConfig = dataModel.getViewConfig(viewId);
    const currentFilter = viewConfig.filter || [];
    // 检查是否已经存在该字段的筛选规则
    const existingFilterIndex = currentFilter.findIndex((filter) => filter.field === columnId);
    let newFilter;
    const isAddingNewFilter = existingFilterIndex < 0;
    if (existingFilterIndex >= 0) {
        // 如果已存在，移除该规则（取消筛选）
        newFilter = currentFilter.filter((_, index) => index !== existingFilterIndex);
    }
    else {
        // 如果不存在，添加新的筛选规则
        // 默认操作符为 'eq'，值为空字符串（用户可以在工具栏中进一步配置）
        const newRule = {
            field: columnId,
            operator: 'eq',
            value: '',
        };
        newFilter = [...currentFilter, newRule];
    }
    // 更新筛选配置
    dataModel.setViewConfig(viewId, {
        filter: newFilter,
    });
    // 选中该列
    setSelectedColumnId(columnId);
    // 如果是添加新筛选规则，触发显示筛选面板
    if (isAddingNewFilter && onShowFilterPanel) {
        // 使用 setTimeout 确保在配置更新后再显示面板
        setTimeout(() => {
            onShowFilterPanel();
        }, 0);
    }
}
/**
 * 处理冻结至此列
 * @param columnId 列ID
 * @param columnIndex 列索引（从0开始）
 * @param viewId 视图ID
 * @param dataModel 数据模型
 * @param viewConfig 视图配置
 */
export function handleFreezeToColumn(columnId, columnIndex, viewId, dataModel, viewConfig) {
    // 冻结至此列，意味着固定到该列（包括该列及之前的所有列）
    // columnIndex 是从 0 开始的索引，所以需要 +1 才是固定列数量
    const newPinnedColumnsCount = columnIndex + 1;
    const columnOrder = viewConfig.columnOrder || [];
    // 获取前 N 列的字段 ID 作为固定字段列表
    const newPinnedFieldIds = columnOrder.slice(0, newPinnedColumnsCount);
    dataModel.setViewConfig(viewId, {
        custom: {
            ...viewConfig.custom,
            pinnedFieldIds: newPinnedFieldIds,
            pinnedColumnsCount: newPinnedFieldIds.length,
        },
    }, true);
}
/**
 * 处理取消冻结列
 * @param columnId 列ID
 * @param columnIndex 列索引（从0开始）
 * @param viewId 视图ID
 * @param dataModel 数据模型
 * @param viewConfig 视图配置
 */
export function handleUnfreezeColumn(columnId, columnIndex, viewId, dataModel, viewConfig) {
    var _a;
    const currentPinnedFieldIds = ((_a = viewConfig.custom) === null || _a === void 0 ? void 0 : _a.pinnedFieldIds) || [];
    const columnOrder = viewConfig.columnOrder || [];
    // 至少保留一个固定字段
    if (currentPinnedFieldIds.length <= 1) {
        return;
    }
    // 从固定列表中移除指定的字段ID（与字段管理器逻辑一致）
    const newPinnedFieldIds = currentPinnedFieldIds.filter((id) => id !== columnId);
    // 重新排列 columnOrder，确保固定字段在前面
    // 1. 获取所有固定字段（保持原有顺序）
    const pinnedColumns = columnOrder.filter((id) => newPinnedFieldIds.includes(id));
    // 2. 获取所有非固定字段（保持原有顺序）
    const unpinnedColumns = columnOrder.filter((id) => !newPinnedFieldIds.includes(id));
    // 3. 固定字段在前，非固定字段在后
    const newColumnOrder = [...pinnedColumns, ...unpinnedColumns];
    dataModel.setViewConfig(viewId, {
        columnOrder: newColumnOrder,
        custom: {
            ...viewConfig.custom,
            pinnedFieldIds: newPinnedFieldIds,
            pinnedColumnsCount: newPinnedFieldIds.length,
        },
    }, true);
}
/**
 * 处理编辑AI列
 * @param columnId 列ID
 * @param dataModel 数据模型
 * @param options 选项参数
 */
export function handleEditAiColumn(columnId, dataModel, viewId, options) {
    var _a, _b, _c;
    const { onSuccess, onError, onOpenEditPanel } = options || {};
    try {
        // 判断是否为 AI 列
        const isAiColumn = (_b = (_a = dataModel.isAiColumn) === null || _a === void 0 ? void 0 : _a.call(dataModel, columnId)) !== null && _b !== void 0 ? _b : false;
        if (!isAiColumn) {
            throw new Error($i18n.get({ id: 'FieldIsNotAnAIColumnAndCannot', dm: '该字段不是 AI 列，无法编辑' }));
        }
        // 从表级 customFields 中获取 AI 列配置
        const columnAiConfig = (_c = dataModel.getCustomFieldAiConfig) === null || _c === void 0 ? void 0 : _c.call(dataModel, columnId);
        if (!columnAiConfig) {
            throw new Error($i18n.get({ id: 'UnableToGetAIColumnConfiguration', dm: '无法获取 AI 列配置' }));
        }
        // 调用回调打开编辑面板，传入完整的配置信息
        // 注意：使用 content（原始 prompt）作为回显，如果不存在则 fallback 到 targetInfo
        if (onOpenEditPanel) {
            onOpenEditPanel({
                columnId,
                columnCode: columnAiConfig.columnCode,
                columnName: columnAiConfig.fieldName,
                promptTemplate: columnAiConfig.content || columnAiConfig.targetInfo,
                fieldType: columnAiConfig.fieldType,
                aiConfig: columnAiConfig,
            });
        }
        if (onSuccess) {
            onSuccess();
        }
    }
    catch (error) {
        console.error('编辑AI列失败:', error);
        if (onError) {
            onError(error);
        }
    }
}
/**
 * 从数据模型中移除字段（内部方法）
 * @param columnId 列ID
 * @param dataModel 数据模型
 */
function removeFieldFromDataModel(columnId, dataModel) {
    // 1. 从 columnDefinitions 中移除
    const newColumnDefinitions = dataModel.columnDefinitions.filter((col) => col.dataIndex !== columnId);
    dataModel.setColumnDefinitions(newColumnDefinitions);
    // 2. 从表级 customFields 中移除
    dataModel.removeCustomField(columnId);
    // 3. 从所有视图配置中移除该字段
    dataModel.viewConfigs.forEach((config, viewId) => {
        const currentColumnOrder = config.columnOrder || [];
        const currentHiddenColumns = config.hiddenColumns || [];
        const newColumnOrder = currentColumnOrder.filter((col) => col !== columnId);
        const newHiddenColumns = currentHiddenColumns.filter((col) => col !== columnId);
        // 同时清理相关的筛选、排序、分组、填色规则
        const newFilter = (config.filter || []).filter((rule) => rule.field !== columnId);
        const newSort = (config.sort || []).filter((rule) => rule.field !== columnId);
        const newGroup = (config.group || []).filter((rule) => rule.field !== columnId);
        const newColorFill = (config.colorFill || []).filter((rule) => rule.field !== columnId);
        dataModel.setViewConfig(viewId, {
            columnOrder: newColumnOrder,
            hiddenColumns: newHiddenColumns,
            filter: newFilter,
            sort: newSort,
            group: newGroup,
            colorFill: newColorFill,
        });
    });
    dataModel.updateRemoteViews();
}
/**
 * 从 AI 列列表中移除（内部方法）
 * @param columnId 列ID
 * @param dataModel 数据模型
 */
function removeFromAiColumns(columnId, dataModel) {
    var _a, _b;
    // 删除普通字段鉴权 TODO: 鸟搭应该是不支持字段删除的
    const currentAiColumns = ((_a = dataModel.getAiColumns) === null || _a === void 0 ? void 0 : _a.call(dataModel)) || dataModel.aiColumns || [];
    const newAiColumns = currentAiColumns.filter((col) => col.columnCode !== columnId);
    (_b = dataModel.setAiColumns) === null || _b === void 0 ? void 0 : _b.call(dataModel, newAiColumns);
}
/**
 * 处理删除字段
 * @param columnId 列ID
 * @param dataModel 数据模型
 * @param options 可选配置
 */
export async function handleDeleteField(columnId, dataModel, options) {
    var _a, _b, _c;
    const { onSuccess, onError } = options || {};
    try {
        // 判断是否为 AI 列
        const isAiColumn = (_b = (_a = dataModel.isAiColumn) === null || _a === void 0 ? void 0 : _a.call(dataModel, columnId)) !== null && _b !== void 0 ? _b : false;
        // 判断是否为公式列
        const isFormulaColumn = !!((_c = dataModel.getCustomFieldFormulaConfig) === null || _c === void 0 ? void 0 : _c.call(dataModel, columnId));
        if (isAiColumn) {
            // AI 列：需要调用接口删除
            const { tableId } = dataModel;
            if (!tableId) {
                throw new Error($i18n.get({
                    id: 'TableIdDoesNotExistCannotDeleteA_1884224232',
                    dm: 'tableId 不存在，无法删除 AI 列',
                }));
            }
            // 调用删除 AI 列接口
            const result = await removeAiColumn({
                tableId,
                columnCode: columnId,
            }, dataModel === null || dataModel === void 0 ? void 0 : dataModel.bizRequestConfig, {
                userCubeConfigRowIdHint: dataModel.cubePlatformUserConfigRowId,
                onUserCubeConfigRowId: (id) => dataModel.setCubePlatformUserConfigRowId(id),
            });
            if (result === null || result === void 0 ? void 0 : result.success) {
                // 接口调用成功，从本地状态中移除
                removeFromAiColumns(columnId, dataModel);
                removeFieldFromDataModel(columnId, dataModel);
                onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess();
            }
            else {
                throw new Error((result === null || result === void 0 ? void 0 : result.errorMsg) ||
                    (result === null || result === void 0 ? void 0 : result.msg) ||
                    $i18n.get({ id: 'FailedToDeleteAIColumn', dm: '删除 AI 列失败' }));
            }
        }
        else if (isFormulaColumn) {
            // 公式列：从本地状态中移除并同步到魔方
            removeFieldFromDataModel(columnId, dataModel);
            onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess();
        }
        else {
            // 普通字段不能删除
            onSuccess === null || onSuccess === void 0 ? void 0 : onSuccess();
        }
    }
    catch (error) {
        console.error('删除字段失败:', error);
        onError === null || onError === void 0 ? void 0 : onError(error);
    }
}
/**
 * 处理编辑公式列
 * @param columnId 列ID
 * @param dataModel 数据模型
 * @param options 选项参数
 */
export function handleEditFormulaColumn(columnId, dataModel, options) {
    var _a;
    const { onOpenEditPanel, onError } = options || {};
    try {
        const formulaConfig = (_a = dataModel.getCustomFieldFormulaConfig) === null || _a === void 0 ? void 0 : _a.call(dataModel, columnId);
        if (!formulaConfig) {
            throw new Error($i18n.get({
                id: 'UnableToRetrieveFormulaFieldConf_1277558698',
                dm: '无法获取公式字段配置',
            }));
        }
        if (onOpenEditPanel) {
            onOpenEditPanel({
                columnId,
                columnCode: formulaConfig.columnCode || columnId,
                columnName: formulaConfig.fieldName,
                expression: formulaConfig.expression,
                referencedFields: formulaConfig.referencedFields || [],
            });
        }
    }
    catch (error) {
        console.error('编辑公式字段失败:', error);
        onError === null || onError === void 0 ? void 0 : onError(error);
    }
}
// ============================================================================
// field-system 统一接口（新代码路径）
// ============================================================================
/**
 * 通过 field-system 统一删除字段（替代 handleDeleteField）。
 * 优先走 orchestrator，识别不了字段类型时 fallback 到旧函数。
 */
export async function deleteFieldViaSystem(columnId, ctx, options) {
    const { registry, orchestrator, store } = getFieldSystem();
    const record = store.getFieldRecord(columnId, ctx.dataModel);
    const fieldType = record === null || record === void 0 ? void 0 : record.type;
    if (!fieldType || !registry.has(fieldType)) {
        await handleDeleteField(columnId, ctx.dataModel, options);
        return;
    }
    const result = await orchestrator.deleteField(fieldType, columnId, ctx, {
        onSuccess: options === null || options === void 0 ? void 0 : options.onSuccess,
        onError: options === null || options === void 0 ? void 0 : options.onError,
    });
    if (!result.success && 'error' in result) {
        console.error('[deleteFieldViaSystem]', result.error);
    }
}
/**
 * 通过 field-system 获取编辑配置（替代 handleEditAiColumn / handleEditFormulaColumn）。
 */
export function getEditConfigViaSystem(columnId, ctx) {
    const { store } = getFieldSystem();
    const record = store.getFieldRecord(columnId, ctx.dataModel);
    if (!record)
        return undefined;
    if (record.type === 'formula') {
        return {
            type: 'formula',
            config: {
                columnId,
                columnCode: record.config.columnCode || columnId,
                columnName: record.name,
                expression: record.config.expression,
                referencedFields: record.config.referencedFields || [],
            },
        };
    }
    if (record.runtime.mode === 'async-task') {
        return {
            type: 'ai',
            config: {
                columnId,
                columnCode: record.config.columnCode || columnId,
                columnName: record.name,
                promptTemplate: record.config.content || record.config.targetInfo,
                fieldType: record.config.fieldType,
                aiConfig: record.config,
            },
        };
    }
    if (record.type === 'lookup') {
        return {
            type: 'lookup',
            config: {
                columnId,
                columnCode: record.config.columnCode || columnId,
                columnName: record.name,
                config: record.config,
            },
        };
    }
    return undefined;
}
