"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getRelativeDateTimestamp = getRelativeDateTimestamp;
exports.getDateRange = getDateRange;
exports.convertRowValueToTimestamp = convertRowValueToTimestamp;
exports.matchDateFilterCondition = matchDateFilterCondition;
exports.handleDateFilter = handleDateFilter;
const dayjs_1 = __importDefault(require("dayjs"));
/**
 * 日期范围选项常量
 */
const RANGE_OPTIONS = [
    'thisWeek',
    'lastWeek',
    'nextWeek',
    'thisMonth',
    'lastMonth',
    'nextMonth',
    'thisYear',
    'lastYear',
    'nextYear',
];
/**
 * 点选项常量
 */
const POINT_OPTIONS = ['today', 'tomorrow', 'yesterday'];
/**
 * 一天的毫秒数
 */
const ONE_DAY_MS = 86400000;
/**
 * 将相对日期选项转换为时间戳
 * @param optionValue 相对日期选项值（如 "today", "thisWeek" 等）
 * @returns 时间戳（毫秒），如果无法转换则返回 null
 */
function getRelativeDateTimestamp(optionValue) {
    const now = (0, dayjs_1.default)();
    const dateMap = {
        today: () => now.startOf('day'),
        tomorrow: () => now.add(1, 'day').startOf('day'),
        yesterday: () => now.subtract(1, 'day').startOf('day'),
        thisWeek: () => now.startOf('week').add(1, 'day'),
        lastWeek: () => now.subtract(1, 'week').startOf('week').add(1, 'day'),
        nextWeek: () => now.add(1, 'week').startOf('week').add(1, 'day'),
        thisMonth: () => now.startOf('month'),
        lastMonth: () => now.subtract(1, 'month').startOf('month'),
        nextMonth: () => now.add(1, 'month').startOf('month'),
        thisYear: () => now.startOf('year'),
        lastYear: () => now.subtract(1, 'year').startOf('year'),
        nextYear: () => now.add(1, 'year').startOf('year'),
    };
    const getDate = dateMap[optionValue];
    return getDate ? getDate().valueOf() : null;
}
/**
 * 获取日期范围的开始和结束时间戳
 * @param rangeType 范围类型（thisWeek, thisMonth, thisYear 等）
 * @param startTimestamp 范围的开始时间戳
 * @returns [开始时间戳, 结束时间戳]
 */
function getDateRange(rangeType, startTimestamp) {
    const startDate = (0, dayjs_1.default)(startTimestamp);
    let endDate;
    if (rangeType.includes('Week')) {
        // 周范围：周一到周日
        endDate = startDate.add(6, 'day').endOf('day');
    }
    else if (rangeType.includes('Month')) {
        // 月范围：月初到月末
        endDate = startDate.endOf('month');
    }
    else if (rangeType.includes('Year')) {
        // 年范围：年初到年末
        endDate = startDate.endOf('year');
    }
    else {
        // 默认只匹配开始日期
        endDate = startDate.endOf('day');
    }
    return [startDate.valueOf(), endDate.valueOf()];
}
/**
 * 将行值转换为时间戳（用于日期比较）
 * @param rowValue 行数据中的字段值（可能是数字时间戳或字符串如 "2025-01-01"）
 * @returns 时间戳（毫秒），如果无法转换则返回 null
 */
function convertRowValueToTimestamp(rowValue) {
    if (rowValue === null || rowValue === undefined || rowValue === '') {
        return null;
    }
    // 1. 如果是数字类型，直接使用
    if (typeof rowValue === 'number') {
        return rowValue;
    }
    // 2. 如果是字符串类型，尝试解析为日期
    if (typeof rowValue === 'string') {
        // 使用 dayjs 解析日期字符串（如 "2025-01-01"）
        const parsed = (0, dayjs_1.default)(rowValue);
        if (parsed.isValid()) {
            // 统一转换为当天的开始时间（00:00:00），确保日期比较的准确性
            return parsed.startOf('day').valueOf();
        }
    }
    // 3. 其他类型无法转换
    return null;
}
/**
 * 将行值转换为时间字符串（用于时间比较）
 * @param rowValue 行数据中的字段值（可能是时间戳或时间字符串如 "01:01:01"）
 * @returns 时间字符串（HH:mm:ss），如果无法转换则返回 null
 */
function convertRowValueToTimeString(rowValue) {
    if (rowValue === null || rowValue === undefined || rowValue === '') {
        return null;
    }
    // 1. 如果是数字类型（时间戳），转换为时间字符串
    if (typeof rowValue === 'number') {
        return (0, dayjs_1.default)(rowValue).format('HH:mm:ss');
    }
    // 2. 如果是字符串类型
    if (typeof rowValue === 'string') {
        // 如果是纯数字字符串（时间戳字符串），转换为时间字符串
        const numValue = Number(rowValue);
        if (!isNaN(numValue) && String(numValue) === rowValue) {
            return (0, dayjs_1.default)(numValue).format('HH:mm:ss');
        }
        // 如果已经是时间字符串格式（HH:mm:ss），直接返回
        const timeMatch = rowValue.match(/^(\d{1,2}):(\d{1,2}):(\d{1,2})$/);
        if (timeMatch) {
            return rowValue;
        }
        // 尝试解析为日期时间字符串
        const parsed = (0, dayjs_1.default)(rowValue);
        if (parsed.isValid()) {
            return parsed.format('HH:mm:ss');
        }
    }
    // 3. 其他类型无法转换
    return null;
}
/**
 * 检查行值是否在日期范围内（辅助函数）
 */
function checkDateRangeMatch(rowValue, rangeStart, rangeEnd, stringValue, filterStringValue) {
    // 行值是 RangePicker 区间 [start, end]
    if (Array.isArray(rowValue) && rowValue.length >= 2) {
        const a = convertRowValueToTimestamp(rowValue[0]);
        const b = convertRowValueToTimestamp(rowValue[1]);
        if (a !== null && b !== null) {
            const lo = Math.min(a, b);
            const hi = (0, dayjs_1.default)(Math.max(a, b)).endOf('day').valueOf();
            return { matched: hi >= rangeStart && lo <= rangeEnd, isDateFilter: true };
        }
    }
    const rowTimestamp = convertRowValueToTimestamp(rowValue);
    if (rowTimestamp === null) {
        return { matched: stringValue === filterStringValue, isDateFilter: true };
    }
    return { matched: rowTimestamp >= rangeStart && rowTimestamp <= rangeEnd, isDateFilter: true };
}
/**
 * 处理日期范围选项匹配（辅助函数）
 */
function handleRangeOptionMatch(filterStringValue, rowValue, stringValue) {
    // 检查是否是日期范围选项名（如 thisWeek、thisMonth 等）
    if (RANGE_OPTIONS.includes(filterStringValue)) {
        const startTimestamp = getRelativeDateTimestamp(filterStringValue);
        if (startTimestamp === null) {
            return { matched: stringValue === filterStringValue, isDateFilter: true };
        }
        const [rangeStart, rangeEnd] = getDateRange(filterStringValue, startTimestamp);
        return checkDateRangeMatch(rowValue, rangeStart, rangeEnd, stringValue, filterStringValue);
    }
    // 检查是否是日期范围格式（如 thisWeek:timestamp）- 兼容旧格式
    const rangeMatch = filterStringValue.match(/^(thisWeek|lastWeek|nextWeek|thisMonth|lastMonth|nextMonth|thisYear|lastYear|nextYear):(\d+)$/);
    if (rangeMatch) {
        const [, rangeType, timestampStr] = rangeMatch;
        const startTimestamp = Number(timestampStr);
        const [rangeStart, rangeEnd] = getDateRange(rangeType, startTimestamp);
        return checkDateRangeMatch(rowValue, rangeStart, rangeEnd, stringValue, filterStringValue);
    }
    return null;
}
/**
 * 匹配日期筛选条件
 * @param rowValue 行数据中的字段值
 * @param operator 操作符
 * @param filterStringValue 筛选值（字符串格式）
 * @param stringValue 行值的字符串表示（用于回退比较）
 * @returns 匹配结果
 */
function matchDateFilterCondition(rowValue, operator, filterStringValue, stringValue) {
    // 对于不等于操作符，先调用等于操作符的逻辑，然后取反
    if (operator === 'ne') {
        const eqResult = matchDateFilterCondition(rowValue, 'eq', filterStringValue, stringValue);
        if (eqResult.isDateFilter) {
            return { matched: !eqResult.matched, isDateFilter: true };
        }
        // 如果等于操作符无法处理，回退到其他比较逻辑
        return { matched: false, isDateFilter: false };
    }
    // 只处理等于操作符的日期筛选（保持原有逻辑）
    if (operator !== 'eq') {
        return { matched: false, isDateFilter: false };
    }
    // 检查是否是自定义日期范围格式（如 dateRange:2026-04-20,2026-05-20）
    if (filterStringValue.startsWith('dateRange:')) {
        const rangeStr = filterStringValue.replace('dateRange:', '');
        const [startStr, endStr] = rangeStr.split(',');
        const rangeStart = (0, dayjs_1.default)(startStr).startOf('day').valueOf();
        const rangeEnd = (0, dayjs_1.default)(endStr).endOf('day').valueOf();
        if (!isNaN(rangeStart) && !isNaN(rangeEnd)) {
            return checkDateRangeMatch(rowValue, rangeStart, rangeEnd, stringValue, filterStringValue);
        }
        return { matched: false, isDateFilter: true };
    }
    // 检查是否是未来/过去天数格式（如 nextDays:7 或 pastDays:7）
    const daysMatch = filterStringValue.match(/^(nextDays|pastDays):(\d+)$/);
    if (daysMatch) {
        const [, daysType, daysStr] = daysMatch;
        const days = Number(daysStr);
        const now = (0, dayjs_1.default)();
        let rangeStart;
        let rangeEnd;
        if (daysType === 'nextDays') {
            // 未来N天：从今天开始到未来N天
            rangeStart = now.startOf('day').valueOf();
            rangeEnd = now
                .add(days - 1, 'day')
                .endOf('day')
                .valueOf();
        }
        else {
            // 过去N天：从N天前到今天
            rangeStart = now
                .subtract(days - 1, 'day')
                .startOf('day')
                .valueOf();
            rangeEnd = now.endOf('day').valueOf();
        }
        return checkDateRangeMatch(rowValue, rangeStart, rangeEnd, stringValue, filterStringValue);
    }
    // 处理日期范围选项匹配
    const rangeMatchResult = handleRangeOptionMatch(filterStringValue, rowValue, stringValue);
    if (rangeMatchResult) {
        return rangeMatchResult;
    }
    // 检查是否是点选项（today, tomorrow, yesterday）
    if (POINT_OPTIONS.includes(filterStringValue)) {
        const targetTimestamp = getRelativeDateTimestamp(filterStringValue);
        if (targetTimestamp === null) {
            return { matched: stringValue === filterStringValue, isDateFilter: true };
        }
        const rowTimestamp = convertRowValueToTimestamp(rowValue);
        if (rowTimestamp === null) {
            return { matched: stringValue === filterStringValue, isDateFilter: true };
        }
        // 比较时间戳（精确到天）
        const rowDate = (0, dayjs_1.default)(rowTimestamp).startOf('day');
        const targetDate = (0, dayjs_1.default)(targetTimestamp).startOf('day');
        return { matched: rowDate.isSame(targetDate), isDateFilter: true };
    }
    // 检查是否是日期/时间区间筛选（JSON 数组格式，如 "[timestamp1,timestamp2]"）
    try {
        const parsedFilter = JSON.parse(filterStringValue);
        if (Array.isArray(parsedFilter) && parsedFilter.length === 2) {
            const [filterStart, filterEnd] = parsedFilter;
            if (typeof filterStart === 'number' && typeof filterEnd === 'number') {
                // 判断是日期区间还是时间区间
                // 方法：检查两个时间戳是否在同一天，且差值小于24小时，则认为是时间区间
                const filterStartDayjs = (0, dayjs_1.default)(filterStart);
                const filterEndDayjs = (0, dayjs_1.default)(filterEnd);
                const timeDiff = Math.abs(filterEnd - filterStart);
                const isSameDay = filterStartDayjs.format('YYYY-MM-DD') === filterEndDayjs.format('YYYY-MM-DD');
                const isTimeRange = isSameDay && timeDiff < ONE_DAY_MS;
                if (!isTimeRange) {
                    // 日期区间筛选：只比较日期部分，忽略时间
                    const filterStartDate = (0, dayjs_1.default)(Math.min(filterStart, filterEnd)).startOf('day').valueOf();
                    const filterEndDate = (0, dayjs_1.default)(Math.max(filterStart, filterEnd)).startOf('day').valueOf();
                    // 解析行值为日期区间（统一转换为日期开始时间）
                    const parseRowDateRange = (value) => {
                        const toDateStart = (ts) => ts !== null ? (0, dayjs_1.default)(ts).startOf('day').valueOf() : null;
                        // 数组格式
                        if (Array.isArray(value) && value.length === 2) {
                            const start = toDateStart(convertRowValueToTimestamp(value[0]));
                            const end = toDateStart(convertRowValueToTimestamp(value[1]));
                            if (start !== null && end !== null) {
                                return [start, end];
                            }
                        }
                        // JSON 字符串格式
                        if (typeof value === 'string') {
                            try {
                                const parsed = JSON.parse(value);
                                if (Array.isArray(parsed) && parsed.length === 2) {
                                    const start = toDateStart(convertRowValueToTimestamp(parsed[0]));
                                    const end = toDateStart(convertRowValueToTimestamp(parsed[1]));
                                    if (start !== null && end !== null) {
                                        return [start, end];
                                    }
                                }
                            }
                            catch {
                                // 日期区间字符串格式（如 "2026-01-03 - 2026-01-09"）
                                const match = value.match(/^(\d{4}-\d{2}-\d{2})\s*-\s*(\d{4}-\d{2}-\d{2})$/);
                                if (match) {
                                    const start = toDateStart(convertRowValueToTimestamp(match[1]));
                                    const end = toDateStart(convertRowValueToTimestamp(match[2]));
                                    if (start !== null && end !== null) {
                                        return [start, end];
                                    }
                                }
                            }
                        }
                        return null;
                    };
                    const rowDateRange = parseRowDateRange(rowValue);
                    if (rowDateRange) {
                        const [rowStartDate, rowEndDate] = rowDateRange;
                        return {
                            matched: rowStartDate === filterStartDate && rowEndDate === filterEndDate,
                            isDateFilter: true,
                        };
                    }
                    // 单个日期值：判断是否在筛选区间内
                    const rowTimestamp = convertRowValueToTimestamp(rowValue);
                    if (rowTimestamp !== null) {
                        const rowDate = (0, dayjs_1.default)(rowTimestamp).startOf('day').valueOf();
                        return {
                            matched: rowDate >= filterStartDate && rowDate <= filterEndDate,
                            isDateFilter: true,
                        };
                    }
                    return { matched: false, isDateFilter: true };
                }
                else {
                    // 时间区间筛选：使用时间字符串进行比较（只比较时间部分，忽略日期）
                    const filterStartTime = filterStartDayjs.format('HH:mm:ss');
                    const filterEndTime = filterEndDayjs.format('HH:mm:ss');
                    // 处理行值：可能是数组或单个值
                    if (Array.isArray(rowValue) && rowValue.length === 2) {
                        // 行值是数组格式 [startTimestamp, endTimestamp]
                        const rowStartTime = convertRowValueToTimeString(rowValue[0]);
                        const rowEndTime = convertRowValueToTimeString(rowValue[1]);
                        if (rowStartTime !== null && rowEndTime !== null) {
                            // 对于"等于"操作符，判断两个区间是否完全相同
                            // 区间相等的条件：rowStart === filterStart && rowEnd === filterEnd
                            return {
                                matched: rowStartTime === filterStartTime && rowEndTime === filterEndTime,
                                isDateFilter: true,
                            };
                        }
                        // 如果无法转换为时间字符串，返回不匹配
                        return { matched: false, isDateFilter: true };
                    }
                    else {
                        // 行值是单个值，尝试转换为时间字符串
                        const rowTimeString = convertRowValueToTimeString(rowValue);
                        if (rowTimeString !== null) {
                            // 单个时间值，判断是否在筛选区间内
                            return {
                                matched: rowTimeString >= filterStartTime && rowTimeString <= filterEndTime,
                                isDateFilter: true,
                            };
                        }
                        // 如果无法转换为时间字符串，返回不匹配
                        return { matched: false, isDateFilter: true };
                    }
                }
            }
        }
    }
    catch {
        // 不是 JSON 格式，继续其他判断
    }
    // 最后检查是否是时间戳字符串（纯数字字符串，可能是时间筛选）
    // 只有在不是日期相关格式的情况下，才进行时间筛选判断
    const isTimestampString = /^\d+$/.test(filterStringValue);
    if (isTimestampString) {
        // 尝试将行值转换为时间字符串
        const rowTimeString = convertRowValueToTimeString(rowValue);
        if (rowTimeString !== null) {
            // 如果行值可以转换为时间字符串，说明这是时间筛选
            // 将筛选值转换为时间字符串进行比较
            const filterTimeString = (0, dayjs_1.default)(Number(filterStringValue)).format('HH:mm:ss');
            // 比较时间字符串（只比较时间部分，忽略日期）
            return { matched: rowTimeString === filterTimeString, isDateFilter: true };
        }
    }
    // 不是日期/时间筛选
    return { matched: false, isDateFilter: false };
}
/**
 * 处理日期筛选逻辑
 */
function handleDateFilter(rowValue, operator, filterValue) {
    const stringValue = String(rowValue);
    const filterStringValue = String(filterValue);
    const dateFilterResult = matchDateFilterCondition(rowValue, operator, filterStringValue, stringValue);
    if (dateFilterResult.isDateFilter) {
        return dateFilterResult.matched;
    }
    // 如果日期筛选逻辑无法处理，返回 null 继续使用其他比较逻辑
    return null;
}
