/**
 * 合并两个对象
 *
 * @param data 第一个对象
 * @param dataExtend 第二个对象，其属性会覆盖第一个对象的同名属性
 * @returns 合并后的新对象
 */
export function mergeObjet(data, dataExtend) {
    let res = {} // 创建合并对象
    if (data != null && data != undefined) {
        for (let key in data) {
            res[key] = data[key]
        }
    }
    // 覆盖前值对象
    if (dataExtend != null && dataExtend != undefined) {
        for (let key in dataExtend) {
            // 忽略空值和NULL
            if (
                dataExtend[key] != undefined &&
                dataExtend[key] != null &&
                dataExtend[key] != ''
            )
                res[key] = dataExtend[key]
        }
    }
    return res
}

/**
 * 格式化银行账号显示格式
 *
 * @param bankNumber 银行账号字符串
 * @returns 格式化后的银行账号字符串，每四位数字用空格隔开
 */
export function formatCardNumber(bankNumber) {
    return bankNumber
        .replace(/\s/g, '')
        .replace(/[^\d]/g, '')
        .replace(/(\d{4})(?=\d)/g, '$1 ')
}

/**
 * 格式化用户名
 *
 * @param name 用户名
 * @param replaceStr 替换字符串，默认为 '*'
 * @returns 格式化后的用户名
 */
export function formatUserName(name, replaceStr = '*') {
    let newName = name
    if (name.length === 2) {
        newName = name[0] + replaceStr
    } else if (name.length > 2) {
        var char = ''
        for (var i = 0, len = name.length - 2; i < len; i++) {
            char += replaceStr
        }
        newName = name[0] + char + name[name.length - 1]
    }
    return newName
}

export function formatPhone(phone) {
    if (phone.length !== 11) {
        return phone
    }
    // 提取前6位和后4位
    const prefix = phone.slice(0, 3)
    const suffix = phone.slice(-4)

    // 生成中间部分的星号
    const maskedMiddle = '****'

    // 拼接成新的字符串
    return prefix + maskedMiddle + suffix
}

export function maskIdCard(idCard) {
    if (idCard.length !== 18) {
        return idCard
    }

    // 提取前6位和后4位
    const prefix = idCard.slice(0, 6)
    const suffix = idCard.slice(-4)

    // 生成中间部分的星号
    const maskedMiddle = '*****'

    console.log(prefix, maskedMiddle, suffix)
    // 拼接成新的字符串
    return prefix + maskedMiddle + suffix
}

export function jsonToString(info) {
    if (info == null) {
        return ''
    }
    return JSON.stringify(info)
}

export function stringToJson(info) {
    if (info == null) {
        return {}
    }
    return JSON.parse(info)
}

export const anyIsEqual = (
    a1,
    a2,
    ignoreArrayPosition = false
) => {
    if (isNil(a1) || isNil(a2)) {
        // 首先判断要比较的两个参数是否为空
        return a1 === a2 // 只要其中一个为空的话，直接返回它们是否相等就可以了
    } else {
        if (a1.constructor === a2.constructor) {
            // 再判断他们的类型是否相等，类型不相等的话，其值也无须判断了
            if (a1.constructor === Array) {
                return arrayIsEqual(a1, a2, ignoreArrayPosition) // 如果是数组，就用数组方式判断是否相等
            } else if (a1.constructor === Object) {
                return objectIsEqual(a1, a2) // 如果是对象，就用对象方式判断是否相等
            } else {
                return a1 === a2 // 其余的直接判断是否相等
            }
        } else {
            return false
        }
    }
}

export const isNil = (v) => {
    return typeof v === 'undefined' || v === null
}

export const arrayIsEqual = (
    a1,
    a2,
    ignoreArrayPosition = false
) => {
    if (a1.length !== a2.length) {
        return false // 判断数组大小是否一致，不一致的话其内容也就不需要判断了
    } else {
        if (!ignoreArrayPosition) {
            return a1.every((v, i) => anyIsEqual(v, a2[i])) // 如果不忽略数组位置的话，也就是说每个数组元素的位置一样，并且其值也一样才判断为相等
        } else {
            return a1.every(
                (v) =>
                a2.findIndex((v2) => anyIsEqual(v2, v)) >= 0 &&
                a2.filter((v2) => anyIsEqual(v2, v)).length ===
                a1.filter((v1) => anyIsEqual(v1, v)).length
            ) // 忽略数据位置的话，那么只要其中一个数组每个元素都可以在另一个数组可以找到，并且每个元素在两个数组的数量是相等的话，那么就可以判定为相等
        }
    }
}

export const objectIsEqual = (
    o1,
    o2
) => {
    if (Object.keys(o1).length !== Object.keys(o2).length) {
        return false // 首先对象属性个数要一致，不一致的话其内容也就不需要判断了
    } else {
        return Object.keys(o1).every((k) => {
            if (Object.keys(o2).includes(k)) {
                return anyIsEqual(o1[k], o2[k])
            } else {
                return false
            } // 只要其中一个对象的属性名在另一个对象存在，就判断其值是否相等就可以了
        })
    }
}