/**
 * 区间表达式格式化工具
 * 将数学区间表达式转换为用户友好的文本描述
 */

/**
 * 格式化区间表达式
 * @param {string} interval - 区间表达式，如 "(0,1000)", "[2000,30000)", "[17,+)"
 * @param {string} unit - 单位，如 "元", "次", "个", "天" 等
 * @returns {string} 格式化后的文本，如果格式化失败则返回原数据
 */
export function formatInterval(interval, unit = "") {
    // 如果数据为空或无效，返回原数据
    if (!interval || interval === "-" || interval === "0") {
        return interval || "-";
    }

    try {
        // 处理特殊格式，如 "3,6(个月)"
        if (interval.includes("(") && interval.includes(")")) {
            const match = interval.match(/^(\d+(?:,\d+)*)\((.+)\)$/);
            if (match) {
                const numbers = match[1].split(",").map((n) => n.trim());
                const timeUnit = match[2];
                if (numbers.length === 2) {
                    return `${numbers[0]}-${numbers[1]}${timeUnit}`;
                }
                return `${numbers.join(", ")}${timeUnit}`;
            }
        }

        // 处理区间表达式
        const intervalPattern =
            /^([\[\(])(\d+(?:\.\d+)?),(\d+(?:\.\d+)?|\+)([\]\)])$/;
        const match = interval.match(intervalPattern);

        // 如果不是区间表达式，返回原数据
        if (!match) {
            return interval;
        }

        const [, leftBracket, leftValue, rightValue, rightBracket] = match;
        const isLeftInclusive = leftBracket === "[";
        const isRightInclusive = rightBracket === "]";
        const isRightInfinity = rightValue === "+";

        let result = "";

        if (isRightInfinity) {
            // 处理无穷大情况，如 "[17,+)"
            if (isLeftInclusive) {
                result = `≥${leftValue}${unit}`;
            } else {
                result = `>${leftValue}${unit}`;
            }
        } else {
            // 处理有限区间
            const leftNum = parseFloat(leftValue);
            const rightNum = parseFloat(rightValue);

            // 检查数值是否有效
            if (isNaN(leftNum) || isNaN(rightNum)) {
                return interval;
            }

            if (leftNum === rightNum) {
                // 单点值
                result = `${leftNum}${unit}`;
            } else {
                // 区间值 - 简化为实际数值范围
                if (isLeftInclusive && isRightInclusive) {
                    result = `${leftNum}-${rightNum}${unit}`;
                } else if (isLeftInclusive && !isRightInclusive) {
                    // 右开区间，显示到 rightNum-1
                    result = `${leftNum}-${rightNum - 1}${unit}`;
                } else if (!isLeftInclusive && isRightInclusive) {
                    // 左开区间，显示从 leftNum+1
                    result = `${leftNum + 1}-${rightNum}${unit}`;
                } else {
                    // 两端都不包含，显示从 leftNum+1 到 rightNum-1
                    result = `${leftNum + 1}-${rightNum - 1}${unit}`;
                }
            }
        }

        return result;
    } catch (error) {
        // 如果格式化过程中出现错误，返回原数据
        console.warn("区间格式化失败:", error, "原数据:", interval);
        return interval;
    }
}

/**
 * 格式化金额区间
 * @param {string} interval - 金额区间表达式
 * @returns {string} 格式化后的金额文本
 */
export function formatAmountInterval(interval) {
    return formatInterval(interval, "元");
}

/**
 * 格式化次数区间
 * @param {string} interval - 次数区间表达式
 * @returns {string} 格式化后的次数文本
 */
export function formatCountInterval(interval) {
    return formatInterval(interval, "次");
}

/**
 * 格式化天数区间
 * @param {string} interval - 天数区间表达式
 * @returns {string} 格式化后的天数文本
 */
export function formatDaysInterval(interval) {
    return formatInterval(interval, "天");
}

/**
 * 格式化机构数量区间
 * @param {string} interval - 机构数量区间表达式
 * @returns {string} 格式化后的机构数量文本
 */
export function formatInstitutionInterval(interval) {
    return formatInterval(interval, "家");
}

/**
 * 格式化时间区间
 * @param {string} interval - 时间区间表达式
 * @returns {string} 格式化后的时间文本
 */
export function formatTimeInterval(interval) {
    if (!interval || interval === "-") {
        return "-";
    }

    // 处理特殊格式，如 "3,6(个月)"
    if (interval.includes("(") && interval.includes(")")) {
        const match = interval.match(/^(\d+(?:,\d+)*)\((.+)\)$/);
        if (match) {
            const numbers = match[1].split(",").map((n) => n.trim());
            const timeUnit = match[2];
            if (numbers.length === 2) {
                return `${numbers[0]}-${numbers[1]}${timeUnit}`;
            }
            return `${numbers.join(", ")}${timeUnit}`;
        }
    }

    return formatInterval(interval, "");
}

/**
 * 格式化申请次数区间
 * @param {string} interval - 申请次数区间表达式，格式如 "2/1"
 * @returns {string} 格式化后的申请次数文本
 */
export function formatApplicationInterval(interval) {
    if (!interval || interval === "-") {
        return "-";
    }

    // 处理 "2/1" 格式，表示 申请次数/机构数
    if (interval.includes("/")) {
        const [applyCount, institutionCount] = interval.split("/");
        return `${applyCount}次/${institutionCount}家`;
    }

    return formatCountInterval(interval);
}

/**
 * 格式化租赁申请数据 - 专门处理司南报告中的 "次数/机构数" 格式
 * @param {string} data - 租赁申请数据，格式如 "2/1" (次数/机构数)
 * @returns {Object} 包含格式化后的次数和机构数的对象
 */
export function formatRentalApplicationData(data) {
    if (!data || data === "-" || data === "0/0") {
        return {
            count: 0,
            institutions: 0,
            countText: "0 次",
            institutionsText: "0 家",
            combinedText: "0 次 / 0 家",
        };
    }

    if (data.includes("/")) {
        const [countStr, institutionsStr] = data.split("/");
        const count = parseInt(countStr) || 0;
        const institutions = parseInt(institutionsStr) || 0;

        return {
            count,
            institutions,
            countText: `${count} 次`,
            institutionsText: `${institutions} 家`,
            combinedText: `${count} 次 / ${institutions} 家`,
        };
    }

    // 如果不是标准格式，返回原数据
    return {
        count: 0,
        institutions: 0,
        countText: data,
        institutionsText: data,
        combinedText: data,
    };
}

/**
 * 格式化风险等级文本
 * @param {string} level - 风险等级，如 "C2,C5"
 * @returns {string} 格式化后的风险等级文本
 */
export function formatRiskLevel(level) {
    if (!level) return "-";

    const levelMap = {
        0: "正常人员",
        A: "前科：侵犯公民人身权利，民主权利",
        A1: "盗窃",
        A2: "诈骗",
        A3: "抢劫/夺",
        A4: "故意伤害/杀人",
        A5: "强奸/性侵/猥亵",
        B: "经济类前科",
        B1: "走私",
        B2: "破坏金融管理秩序",
        B3: "正常人员",
        B4: "洗钱",
        B5: "洗钱",
        C: "妨害社会管理秩序",
        C1: "扰乱公共秩序",
        C2: "妨害司法",
        C3: "涉毒",
        C4: "涉黄刑案",
        C5: "帮信/掩隐/侵公",
        D: "重点",
        D1: "危害国家、公共安全",
        D2: "涉稳",
        D3: "涉及境外",
        D4: "涉恐、疆藏",
        D5: "涉黑",
        E: "涉交通案件",
        F: "法院文书",
    };

    return level
        .split(",")
        .map((l) => levelMap[l.trim()] || l.trim())
        .join("、");
}

/**
 * 格式化状态文本
 * @param {string} status - 状态值
 * @param {Object} statusMap - 状态映射对象
 * @returns {string} 格式化后的状态文本
 */
export function formatStatus(status, statusMap = {}) {
    if (status === undefined || status === null || status === "") {
        return "-";
    }

    return statusMap[status] || status;
}

/**
 * 格式化风险标识
 * @param {number} flag - 风险标识，0=未查得，1=高风险，2=低风险
 * @returns {Object} 包含文本和样式的对象
 */
export function formatRiskFlag(flag) {
    const flagMap = {
        0: { text: "未查得", class: "bg-gray-100 text-gray-700" },
        1: { text: "高风险", class: "bg-red-100 text-red-700" },
        2: { text: "低风险", class: "bg-green-100 text-green-700" },
    };

    return (
        flagMap[flag] || { text: "未知", class: "bg-gray-100 text-gray-700" }
    );
}

/**
 * 格式化验证结果
 * @param {string} result - 验证结果
 * @returns {Object} 包含文本和样式的对象
 */
export function formatVerificationResult(result) {
    const resultMap = {
        一致: { text: "一致", class: "text-green-600" },
        不一致: { text: "不一致", class: "text-red-600" },
        验证通过: { text: "验证通过", class: "text-green-600" },
        验证失败: { text: "验证失败", class: "text-red-600" },
    };

    return resultMap[result] || { text: result || "-", class: "text-gray-600" };
}
