import { matchFilterCondition, getComparisonFlags, normalizeDetailValue, } from './filters/customFilterFns';
/**
 * 解析颜色字符串为 rgba 对象
 * 支持 hex (#RRGGBB) 和 rgba(r, g, b, a) 格式
 */
function parseColor(colorStr) {
    const trimmed = colorStr.trim();
    // 检查是否是 rgba 格式
    const rgbaMatch = trimmed.match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)(?:,\s*([\d.]+))?\)$/);
    if (rgbaMatch) {
        return {
            r: parseInt(rgbaMatch[1], 10),
            g: parseInt(rgbaMatch[2], 10),
            b: parseInt(rgbaMatch[3], 10),
            a: rgbaMatch[4] ? parseFloat(rgbaMatch[4]) : 1,
        };
    }
    // 检查是否是 hex 格式
    if (trimmed.startsWith('#')) {
        let hex = trimmed.replace(/^#/, '');
        // 处理 3 位 hex 缩写
        if (hex.length === 3) {
            hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
        }
        return {
            r: parseInt(hex.substring(0, 2), 16),
            g: parseInt(hex.substring(2, 4), 16),
            b: parseInt(hex.substring(4, 6), 16),
            a: 1, // hex 默认不透明
        };
    }
    // 默认返回黑色
    return { r: 0, g: 0, b: 0, a: 1 };
}
/**
 * 叠加多个颜色，返回最终的颜色
 * 使用 alpha 混合算法，按照规则顺序叠加
 * 直接使用预设颜色本身的透明度，不再动态调整
 */
function blendColors(colors) {
    if (colors.length === 0)
        return '';
    if (colors.length === 1)
        return colors[0];
    // 从第一个颜色开始叠加
    let result = parseColor(colors[0]);
    // 依次叠加后续颜色
    for (let i = 1; i < colors.length; i++) {
        const topColor = parseColor(colors[i]);
        // Alpha 混合公式（标准的 Porter-Duff Source Over 算法）
        const outAlpha = topColor.a + result.a * (1 - topColor.a);
        if (outAlpha === 0) {
            result = { r: 0, g: 0, b: 0, a: 0 };
        }
        else {
            result = {
                r: (topColor.r * topColor.a + result.r * result.a * (1 - topColor.a)) / outAlpha,
                g: (topColor.g * topColor.a + result.g * result.a * (1 - topColor.a)) / outAlpha,
                b: (topColor.b * topColor.a + result.b * result.a * (1 - topColor.a)) / outAlpha,
                a: outAlpha,
            };
        }
    }
    // 转换回 rgba 字符串
    return `rgba(${Math.round(result.r)}, ${Math.round(result.g)}, ${Math.round(result.b)}, ${result.a.toFixed(3)})`;
}
/**
 * 检查单元格值是否匹配填色规则
 * 使用与筛选功能相同的逻辑，确保行为一致
 * @param cellValue 单元格值
 * @param rule 填色规则
 * @param componentType 字段组件类型，用于判断比较方式
 * @param fieldSchema 字段 schema，用于 normalizeDetailValue 归一化 object 行值
 */
export function matchColorFillRule(cellValue, rule, componentType, fieldSchema) {
    if (!rule.field || !rule.operator) {
        return false;
    }
    // 对于 empty 和 notEmpty，如果没有值也允许匹配（与筛选逻辑一致）
    // 但对于其他操作符，如果没有值则不匹配（需要有具体值才填色）
    if (rule.operator !== 'empty' && rule.operator !== 'notEmpty') {
        if (!rule.value || String(rule.value).trim() === '') {
            return false;
        }
    }
    const { isNumericComparison, isDateComparison, isEmployeeSelect } = getComparisonFlags(componentType);
    // 当字段启用 useDetailValue 时，从 object 行值中提取 x-fieldKey 指定的真实比较值
    const normalizedCellValue = normalizeDetailValue(cellValue, fieldSchema);
    return matchFilterCondition(normalizedCellValue, rule.operator, rule.value, isNumericComparison, isDateComparison, isEmployeeSelect);
}
/**
 * 收集当前单元格命中的所有填色规则颜色（内部复用）
 */
function collectMatchedColors(rowData, columnId, colorFillRules, fieldMap) {
    const matchedColors = [];
    for (const rule of colorFillRules) {
        const scope = rule.scope || 'cell';
        if (scope === 'column') {
            if (rule.field === columnId) {
                matchedColors.push(rule.color);
            }
        }
        else {
            const cellValue = rowData[rule.field];
            const fieldSchema = fieldMap === null || fieldMap === void 0 ? void 0 : fieldMap[rule.field];
            const componentType = fieldSchema === null || fieldSchema === void 0 ? void 0 : fieldSchema['x-component'];
            const isMatch = matchColorFillRule(cellValue, rule, componentType, fieldSchema);
            if (!isMatch) {
                continue;
            }
            if (scope === 'cell') {
                if (rule.field === columnId) {
                    matchedColors.push(rule.color);
                }
            }
            else if (scope === 'row') {
                matchedColors.push(rule.color);
            }
        }
    }
    return matchedColors;
}
/**
 * 获取单元格应该应用的填色规则（返回所有匹配规则的颜色叠加结果）
 * @param rowData 行数据
 * @param columnId 列ID
 * @param colorFillRules 填色规则列表
 * @param fieldMap 字段配置映射，用于获取字段组件类型
 */
export function getCellColorFill(rowData, columnId, colorFillRules, fieldMap) {
    if (!colorFillRules || colorFillRules.length === 0) {
        return null;
    }
    const matchedColors = collectMatchedColors(rowData, columnId, colorFillRules, fieldMap);
    if (matchedColors.length > 0) {
        return blendColors(matchedColors);
    }
    return null;
}
/**
 * 获取单元格命中的每条填色规则的独立颜色列表（不预混合）
 * 用于 CSS 多层叠加：每种颜色生成一个独立的 gradient 层，
 * 由浏览器原生 alpha 合成，支持同时可见多条半透明填色。
 */
export function getCellColorFillLayers(rowData, columnId, colorFillRules, fieldMap) {
    if (!colorFillRules || colorFillRules.length === 0) {
        return [];
    }
    return collectMatchedColors(rowData, columnId, colorFillRules, fieldMap);
}
