import isNil from 'ramda/es/isNil';

/**
 * 将流量数值格式化为可读字符串（按 1024 进制：bit, Kb, Mb, Gb...）
 * @param traffic 流量数值，单位由 isByte 决定
 * @param isByte 若为 true 则 traffic 为字节，会乘以 8 转为 bit；若为 false 则 traffic 已为 bit
 * @returns 格式化后的字符串，如 "1.5Gb"；空值或 undefined 返回 "-"
 */
export const formatTraffic = (traffic: number | undefined, isByte: boolean = true) => {
    if (isNil(traffic)) return '-';
    if (traffic === 0) return '0B';
    let bits = traffic;
    if (isByte === true) {
        bits = bits * 8;
    }
    const units = ['bit', 'Kb', 'Mb', 'Gb', 'Tb', 'Pb', 'Eb', 'Zb', 'Yb'];
    const index = Math.floor(Math.log(bits) / Math.log(1024));
    return `${(bits / Math.pow(1024, index)).toFixed(1)}${units[index]}`;
};

/**
 * 将带宽数值格式化为可读字符串（按 1000 进制：bps, Kbps, Mbps, Gbps...）
 * @param bandwidth 带宽数值，单位由 isByte 决定
 * @param isByte 若为 true 则 bandwidth 为字节/秒，会乘以 8 转为 bps；若为 false 则已为 bps
 * @returns 格式化后的字符串，如 "100.0Mbps"；空值、undefined 或 ≤0 返回 "-" 或 "0bps"
 */
export const formatBandwidth = (bandwidth: number | undefined, isByte: boolean = true) => {
    if (isNil(bandwidth)) return '-';
    if (bandwidth <= 0) return '0bps';
    let bits = bandwidth;
    if (isByte === true) {
        bits = bits * 8;
    }
    const units = ['bps', 'Kbps', 'Mbps', 'Gbps', 'Tbps', 'Pbps', 'Ebps', 'Zbps', 'Ybps'];
    const index = Math.floor(Math.log(bits) / Math.log(1000));
    return `${(bits / Math.pow(1000, index)).toFixed(1)}${units[index]}`;
};

/**
 * 将磁盘容量格式化为可读字符串（按 1000 进制：B, K, M, G, T...）
 * @param size 容量数值，单位由 isByte 决定
 * @param isByte 若为 true 则 size 为字节；若为 false 则 size 为 bit，会除以 8 转为字节
 * @returns 格式化后的字符串，如 "500.0G"；空值或 undefined 返回 "-"
 */
export const formatDiskSize = (size: number | undefined, isByte: boolean = true) => {
    if (isNil(size)) return '-';
    if (size === 0) return '0B';
    let bytes = size;
    if (isByte === false) {
        bytes = bytes / 8;
    }
    const units = ['B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
    const index = Math.floor(Math.log(bytes) / Math.log(1000));
    return `${(bytes / Math.pow(1000, index)).toFixed(1)}${units[index]}`;
};

/**
 * 将内存大小格式化为可读字符串（按 1024 进制：B, K, M, G, T...）
 * @param size 内存数值，单位由 isByte 决定
 * @param isByte 若为 true 则 size 为字节；若为 false 则 size 为 bit，会除以 8 转为字节
 * @returns 格式化后的字符串，如 "8.0G"；空值或 undefined 返回 "-"
 */
export const formatMemorySize = (size: number | undefined, isByte: boolean = true) => {
    if (isNil(size)) return '-';
    if (size === 0) return '0B';
    let bytes = size;
    if (isByte === false) {
        bytes = bytes / 8;
    }
    const units = ['B', 'K', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
    const index = Math.floor(Math.log(bytes) / Math.log(1024));
    return `${(bytes / Math.pow(1024, index)).toFixed(1)}${units[index]}`;
};
