/**
 * 字符串处理模块
 */
export module tsString {
    /**
     * 将任意类型格式化为string类型
     * @param arg 任意类型
     * @returns
     */
    export function toString(arg: any): string {
        let str = ''
        let typ = typeof arg
        // typ: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
        if (typ == 'undefined') {
            str = typ
        } else if (typ == 'object') {
            if (arg == null) {
                str = 'null'
            } else {
                str = JSON.stringify(arg)
            }
        } else {
            str = arg.toString()
        }
        return str
    }

    /**
     * 格式化字符串-指定类型
     * @param message 带格式的字符串（"example: {0}, {1}"）
     * @param replacements strng类型参数（["hello", "world"]）
     * @returns "example: hello, world"
     */
    export function formats(message: string, ...replacements: string[]): string {
        var args = replacements
        return message.replace(/{(\d+)}/g, function (match, number): string {
            return typeof args[number] !== 'undefined' ? args[number] : match
        })
    }

    /**
     * 格式化字符串
     * @param message 带格式的字符串（"example: {0}, {1} {2}"）
     * @param replacements 任意类型参数（["hello", "world", 2023]）
     * @returns "example: hello, world 2023"
     */
    export function format(message: string, ...replacements: any[]): string {
        var args = replacements
        return message.replace(/{(\d+)}/g, function (match, number): string {
            return toString(args[number])
        })
    }

    /**
     * 字符串去空格
     * @param value
     * @returns
     */
    export function trim(value: string): string {
        let str = value
        if (String.prototype.trim) {
            str = value.trim()
        } else {
            str = value.replace(/(^\s*)|(\s*$)/g, '')
        }
        return str
    }

    /**
     * 字符串是否为空
     * @param value 字符串
     * @returns 空：true 非空：false
     */
    export function isNullOrEmpty(value: any): boolean {
        if (typeof value != 'string') {
            return true
        }
        let str = trim(value)
        return str == '' || str == 'null' || str == 'nil' || str == 'undefined'
    }

    /**
     * 安全encodeURI
     * @param value
     * @returns
     */
    export function encodeURI(value: string): string {
        if (isNullOrEmpty(value)) {
            return ''
        }
        return value.replace(/[\u4e00-\u9fa5]/g, function ($) {
            return encodeURI($)
        })
    }

    const fillNumbers: string[] = ['', '0', '00', '000', '0000', '00000', '000000', '0000000', '00000000', '000000000']
    /**
     * 格式化number
     * @param n number (example: 1)
     * @param len 长度 (example: 3)
     * @returns (example: "001")
     */
    export function formatNumber(n: number, len: number): string {
        let s = n.toString()
        let diff = len - s.length
        return fillNumbers[diff] + s
    }

    /**
     * 格式化输出Object属性，用于调式
     * @param obj
     * @returns
     */
    export function formatObjectProperty(obj: any): string {
        if (!obj) {
            return ''
        }
        let str = ''
        Object.getOwnPropertyNames(obj).forEach(function (key) {
            let typ = typeof obj[key]
            if (typ == 'function' || typ == 'object') {
                str += tsString.format('{0}:{1} ', key, typ)
            } else if (key.indexOf('_') == -1) {
                str += tsString.format('{0}:{1} ', key, obj[key])
            }
        })
        return str
    }
}