"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isDatePickerType = isDatePickerType;
exports.isTimePickerType = isTimePickerType;
exports.isTimeZoneDatePickerType = isTimeZoneDatePickerType;
exports.formatTimeZoneDateToDisplayString = formatTimeZoneDateToDisplayString;
exports.parseDynamicDateDays = parseDynamicDateDays;
exports.parseDynamicDateOption = parseDynamicDateOption;
exports.parseDynamicDateNaturalLanguageToValue = parseDynamicDateNaturalLanguageToValue;
exports.formatTimestampToDateStringArray = formatTimestampToDateStringArray;
exports.formatTimestampToTimeStringArray = formatTimestampToTimeStringArray;
exports.formatSingleDateTimeValue = formatSingleDateTimeValue;
exports.calculateDynamicDateRange = calculateDynamicDateRange;
exports.formatDateTimeValue = formatDateTimeValue;
const i18n_1 = __importDefault(require("../../../locales/i18n.js"));
/**
 * Display 层：日期时间选择器工具函数
 * 职责：将时间戳转换为显示文本
 */
const dayjs_1 = __importDefault(require("dayjs"));
const date_shortcuts_1 = require("../constants/date-shortcuts");
/**
 * 默认日期时间格式
 */
const DEFAULT_DATETIME_FORMAT = 'YYYY-MM-DD HH:mm:ss';
/**
 * 日期选择器组件类型列表
 */
const DATE_PICKER_TYPES = [
    'DatePicker',
    'CnDatePickerPro',
    'RangePicker',
    'CnRangeDatePickerPro',
];
/**
 * 时间选择器组件类型列表
 */
const TIME_PICKER_TYPES = [
    'TimePicker',
    'RangeTimePicker',
    'CnTimePickerPro',
    'CnRangeTimePickerPro',
];
/**
 * 判断是否为日期选择器组件
 */
function isDatePickerType(columnType) {
    return DATE_PICKER_TYPES.includes(columnType);
}
/**
 * 判断是否为时间选择器组件
 */
function isTimePickerType(columnType) {
    return TIME_PICKER_TYPES.includes(columnType);
}
const TIME_ZONE_DATE_PICKER_TYPES = ['CnTimeZoneDatePicker', 'CnTimeZoneRangeDatePicker'];
/** 判断是否为时区日期选择器组件 */
function isTimeZoneDatePickerType(columnType) {
    return TIME_ZONE_DATE_PICKER_TYPES.includes(columnType);
}
/** 根据 zoneId 和可选时间戳得到 (UTC+08:00) 格式的偏移展示 */
function getTimezoneOffsetDisplay(zoneId, timestamp) {
    try {
        const d = timestamp != null ? new Date(timestamp) : new Date();
        const formatter = new Intl.DateTimeFormat('en-US', {
            timeZone: zoneId,
            timeZoneName: 'longOffset',
        });
        const parts = formatter.formatToParts(d);
        const tz = parts.find((p) => p.type === 'timeZoneName');
        if (!(tz === null || tz === void 0 ? void 0 : tz.value))
            return `(${zoneId})`;
        const match = tz.value.replace(/^GMT/i, '').match(/^([+-])(\d{1,2})(?::(\d{2}))?/);
        if (match) {
            const [, sign, h, m] = match;
            return `(UTC${sign}${String(h).padStart(2, '0')}:${String(m || '00').padStart(2, '0')})`;
        }
        return `(${tz.value})`;
    }
    catch {
        return `(${zoneId})`;
    }
}
/** 时区日期值格式化为显示字符串（图1：仅日期 + UTC 偏移，如 2026-02-27 (UTC+08:00)） */
function formatTimeZoneDateToDisplayString(value, dateFormat = 'YYYY-MM-DD') {
    // 如果 value 为空，或者是只有 zoneId 没有 timestamp 的对象，返回空字符串
    if (value == null)
        return '';
    // 处理单个对象的情况：{ zoneId: '...', timestamp: null/undefined } 或 { zoneId: '...' }
    if (!Array.isArray(value) && typeof value === 'object') {
        // 如果没有 timestamp 字段，或者 timestamp 为 null/undefined，返回空字符串
        if (value.timestamp == null)
            return '';
    }
    const items = Array.isArray(value) ? value : [value];
    return items
        .filter((v) => v && typeof v === 'object' && ('timestamp' in v || 'zoneId' in v))
        .flatMap((v) => {
        // 兼容后端返回的两种格式：
        // 1. { zoneId, timestamp: number } - 标准单值格式
        // 2. { zoneId, timestamp: [number, number] } - 区间格式（需要展开为两个对象）
        const timestamps = Array.isArray(v.timestamp) ? v.timestamp : [v.timestamp];
        return timestamps.map((ts) => {
            // 如果没有时间戳，不显示任何内容（包括时区）
            if (ts == null)
                return '';
            const dateStr = (0, dayjs_1.default)(ts).format(dateFormat);
            const zone = v.zoneId ? ` ${getTimezoneOffsetDisplay(v.zoneId, ts)}` : '';
            return dateStr + zone;
        });
    })
        .filter(Boolean)
        .join(' - ');
}
/** 解析动态日期选项的天数（未来:X / 过去:X），无法解析返回 7 */
function parseDynamicDateDays(dynamicValue) {
    const days = parseInt(dynamicValue.replace(/^(未来|过去):/, ''), 10);
    return Number.isNaN(days) ? 7 : days;
}
/** 解析动态日期选项为显示文案（如 "未来 7 天内"），非动态选项返回 null */
function parseDynamicDateOption(value) {
    if (!value.startsWith('未来:') && !value.startsWith('过去:'))
        return null;
    const days = parseDynamicDateDays(value);
    const label = value.startsWith('未来:')
        ? i18n_1.default.get({ id: 'Future', dm: '未来' })
        : i18n_1.default.get({ id: 'Past', dm: '过去' });
    return i18n_1.default.get({
        id: 'WithinLabelDays',
        dm: '{label} {days} 天内',
    }, { label, days });
}
/** 从自然语言解析为动态日期 value（如 "未来 7 天内" → "未来:7"），不匹配返回 null */
function parseDynamicDateNaturalLanguageToValue(naturalLanguage) {
    const match = naturalLanguage.match(/^(未来|过去)\s+(\d+)\s+天内$/);
    return match ? `${match[1]}:${match[2]}` : null;
}
/**
 * 处理字符串类型的特殊格式
 * @param value - 字符串值
 * @returns 格式化后的字符串数组，如果不是特殊格式则返回 null
 */
function handleSpecialStringFormats(value) {
    // 处理动态日期选项格式：未来:7、过去:7
    const dynamicDateOption = parseDynamicDateOption(value);
    if (dynamicDateOption) {
        return [dynamicDateOption];
    }
    // 处理日期范围格式：开始日期至结束日期:start,end
    if (value.startsWith(`${date_shortcuts_1.DATE_RANGE_OPTION}:`)) {
        const [startDate, endDate] = value.replace(`${date_shortcuts_1.DATE_RANGE_OPTION}:`, '').split(',');
        if (startDate && endDate)
            return [
                i18n_1.default.get({
                    id: 'StartDateToEndDate.6tqtG',
                    dm: '{startDate} 至 {endDate}',
                }, { startDate, endDate }),
            ];
        return [value];
    }
    // 处理已格式化的日期范围格式：YYYY-MM-DD HH:mm:ss 至 YYYY-MM-DD HH:mm:ss
    if (value.includes(' 至 ')) {
        return [value];
    }
    // 处理日期快捷选项（中文值，如"今天"、"本周"）
    if ((0, date_shortcuts_1.isDateShortcut)(value)) {
        return [(0, date_shortcuts_1.getDateShortcutLabel)(value)];
    }
    return null;
}
/**
 * 格式化时间戳数组为字符串数组（通用函数）
 * @param value - 时间戳值（可能是数字、数组等）
 * @param format - 时间格式
 * @returns 格式化后的字符串数组
 */
function formatTimestampArray(value, format) {
    // 处理字符串类型的特殊格式
    if (typeof value === 'string') {
        const specialFormat = handleSpecialStringFormats(value);
        if (specialFormat) {
            return specialFormat;
        }
    }
    // 处理数组类型（区间选择器）
    if (Array.isArray(value)) {
        // 如果数组元素是数字，直接格式化
        if (value.length > 0 && typeof value[0] === 'number') {
            return value.map((ts) => (0, dayjs_1.default)(ts).format(format));
        }
        // 无法识别为时间戳数组，转换为字符串数组
        return value.map((v) => String(v));
    }
    // 处理单个数字类型（时间戳）
    if (typeof value === 'number') {
        return [(0, dayjs_1.default)(value).format(format)];
    }
    // 其他类型，转换为字符串数组
    return [String(value)];
}
/**
 * 格式化时间戳为日期字符串数组
 * @param value - 时间戳值
 * @param format - 日期格式，默认为 'YYYY-MM-DD'
 */
function formatTimestampToDateStringArray(value, format = 'YYYY-MM-DD') {
    // formatTimestampArray 已经处理了字符串类型的特殊格式，直接调用即可
    return formatTimestampArray(value, format);
}
/**
 * 格式化时间戳为时间字符串数组
 * @param value - 时间戳值
 * @param format - 时间格式，默认为 'HH:mm:ss'
 */
function formatTimestampToTimeStringArray(value, format = 'HH:mm:ss') {
    // formatTimestampArray 已经处理了字符串类型的特殊格式，直接调用即可
    return formatTimestampArray(value, format);
}
/**
 * 格式化单个值为日期时间字符串
 * @param v - 值（日期时间字符串或时间戳）
 * @param format - 日期格式（优先使用用户配置的 format，默认为 "YYYY-MM-DD HH:mm:ss"）
 * @returns 格式化后的日期时间字符串
 */
function formatSingleDateTimeValue(v, format) {
    const finalFormat = format || DEFAULT_DATETIME_FORMAT;
    // 处理数字类型（时间戳）
    if (typeof v === 'number') {
        return (0, dayjs_1.default)(v).format(finalFormat);
    }
    if (typeof v === 'string') {
        // 尝试解析为日期时间，使用指定的 format 格式化
        const parsed = (0, dayjs_1.default)(v);
        if (parsed.isValid()) {
            return parsed.format(finalFormat);
        }
        // 无法解析，直接返回原字符串
        return v;
    }
    return String(v);
}
/**
 * 计算动态日期选项的具体日期时间范围
 * @param dynamicValue - 动态日期选项值（未来:X 或 过去:X）
 * @param format - 日期格式（优先使用用户配置的 format，默认为 "YYYY-MM-DD HH:mm:ss"）
 * @returns 格式化的日期时间范围字符串
 */
function calculateDynamicDateRange(dynamicValue, format) {
    const finalFormat = format || DEFAULT_DATETIME_FORMAT;
    const now = (0, dayjs_1.default)();
    const days = parseDynamicDateDays(dynamicValue);
    const isFuture = dynamicValue.startsWith('未来:');
    const rangeStart = isFuture ? now.startOf('day') : now.subtract(days - 1, 'day').startOf('day');
    const rangeEnd = isFuture ? now.add(days - 1, 'day').endOf('day') : now.endOf('day');
    return `${rangeStart.format(finalFormat)}, ${rangeEnd.format(finalFormat)}`;
}
/**
 * 格式化日期时间值为字符串
 * @param value - 日期时间值（可能是数组、数字、字符串等）
 * @param format - 日期格式（优先使用用户配置的 format，默认为 "YYYY-MM-DD HH:mm:ss"）
 * @returns 格式化后的日期时间字符串
 */
function formatDateTimeValue(value, format) {
    if (Array.isArray(value) && value.length > 0) {
        const first = value[0];
        if (typeof first === 'string' && (0, date_shortcuts_1.getDateFilterValueType)(first) === 'dynamic') {
            return calculateDynamicDateRange(first, format);
        }
        return value.map((v) => formatSingleDateTimeValue(v, format)).join(', ');
    }
    if (typeof value === 'number' || typeof value === 'string') {
        return formatSingleDateTimeValue(value, format);
    }
    // 其他类型，使用默认格式化（formatTimestampToDateStringArray 返回数组，需要 join）
    const formatted = formatTimestampToDateStringArray(value);
    return formatted.join(', ');
}
