export const wrapTreeNode = (data: any) => {
    const wrapData: any = data.map((item: any) => {
        const node = { ...item.node };

        if (item.children && item.children.length > 0) {
            node.children = wrapTreeNode(item.children);
        }
        return node
    });
    return wrapData;
}

// 若有小数保留两位小数 没有小数不保留
export const formatNumber = (num: number) => {
    // 判断是否是小数
    if (num % 1 !== 0) {
        return num.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
    } else {
        return num.toLocaleString(); // 使用千分号，不保留小数位
    }
}

export const formatNumberData = (value: number): string => {
    if (isNaN(value)) return "";  // 如果输入值不是数字，返回空字符串
    // 判断是否有小数
    const isInteger = value % 1 === 0;
    // 添加千分号
    let formattedValue = value.toLocaleString('en-US');
    // 如果有小数，保留两位小数
    if (!isInteger) {
        formattedValue = parseFloat(value.toFixed(2)).toLocaleString('en-US');
    }
    return formattedValue;
};

// 把可能是带千分号的数字 变为数字
export const parseThousandSeparatedNumber = (str: string) => {
    if (!str) return 0; // 如果字符串为空，返回0
    const cleaned = str.replace(/,/g, ""); // 移除千分号
    return parseFloat(cleaned); // 转换为数字
};

// 截取小数点2位  输出带千分号的 
export const formatNumberTo = (num: number) => {
    // 判断是否是数字
    if (isNaN(num) || num === 0) {
        return "0.00";
    }

    // 限制小数点后最多两位
    let number: any = num.toFixed(2);

    // 添加千分位
    const [integer, decimal] = number.split('.');

    const formattedInteger = integer.replace(/\B(?=(\d{3})+(?!\d))/g, ','); // 添加千分位

    // 返回带千分位和保留两位小数的数字
    return `${formattedInteger}.${decimal}`;
}


// 五位数字显示  不够的前面补齐0
export const handleGetFiveNumber = (input: any) => {
    let inputStr = input.toString()
    if (inputStr > 10000) {
        return {
            paddedPart: "",
            originalNum: inputStr.toLocaleString()
        };
    }

    let num = Number(input);

    // 判断这个数字里面是否有小数
    let havePonit = num.toString().includes('.');

    let paddedPart: string = ''
    let originalNum: string = ''

    if (havePonit) {
        // 小数点前面的数字 
        let paddingLeft = num.toString().split('.')[0]
        // 小数点后面的数字
        let paddingRight = num.toString().split('.')[1]

        let newLeftStr: string = ''
        let newRightStr: string = ''

        if (paddingLeft.length >= 4) {
            newLeftStr = paddedPart.toLocaleString()
            newRightStr = paddingRight[0]
        } else {
            newLeftStr = paddingLeft.toString().padStart(3, '0');
            newRightStr = `${paddingRight[0]}${paddingRight[1]}`
        }



        const match = newLeftStr.match(/^(0+)([1-9]\d*|0$)/);

        if (match) {
            return {
                paddedPart: match[1],
                originalNum: match[2] + `.${newRightStr}`
            }
            // [match[1], match[2]]; // 返回 [前导零, 剩余部分]
        }
        return {
            paddedPart: "",
            originalNum: `${newLeftStr}.${newRightStr}`
        }

    } else {
        let newStr = num.toString().padStart(5, '0');
        const match = newStr.match(/^(0+)([1-9]\d*|0$)/);

        if (match) {
            let newAllStr: string = `${match[1]}${num}`.toLocaleString()
            // 确保输入是字符串
            const str = newAllStr;
            // 计算逗号位置
            const commaPos = str.length - 3;
            let newStrStr: string = str.slice(0, commaPos) + ',' + str.slice(commaPos);

            if (newStrStr.indexOf(',') !== -1) {
                let newPaddedPart: string = newStrStr.split(num.toString())[0]
                return {
                    paddedPart: newPaddedPart,
                    originalNum: num
                }
            } else {
                return {
                    paddedPart: match[1],
                    originalNum: num
                }
            }
            // [match[1], match[2]]; // 返回 [前导零, 剩余部分]
        }
        return {
            paddedPart: "",
            originalNum: num
        }
    }


    // let num = Number(input);
    // let isFloat = !Number.isInteger(num);

    // // 格式化数字（保留两位小数）
    // let formatted = isFloat ? num.toFixed(2) : String(num);
    // let withoutDot = formatted.replace('.', ''); // 暂时移除小数点方便长度判断

    // // 计算补零数量（目标是补齐5位）
    // let padLen = Math.max(5 - withoutDot.length, 0);
    // let paddedStr = '0'.repeat(padLen) + withoutDot;

    // // 插回小数点（如果有）
    // if (isFloat) {
    //     let intPartLen = paddedStr.length - 2;
    //     paddedStr = paddedStr.slice(0, intPartLen) + '.' + paddedStr.slice(intPartLen);
    // }

    // // 拆分出补零部分和原始数字
    // let originalLen = formatted.replace('.', '').length;
    // let paddedPartRaw = paddedStr.slice(0, padLen);
    // let paddedPart = paddedPartRaw;

    // // 添加千分号（如果补零部分大于等于4位）
    // if (paddedPartRaw.length >= 4) {
    //     paddedPart = paddedPartRaw.replace(/(\d)(?=(\d{3})+$)/g, '$&,');
    // }

    return {
        paddedPart: paddedPart,
        originalNum: originalNum
    };
}