import { Injectable } from '@angular/core';
import { BigNumber } from 'bignumber.js';

export type NumberType = string | number;

@Injectable({
    providedIn: 'root'
})
export class NumberHelperService {
    constructor() { }

    formatMoney(value, opts: any = {}): string {
        return this.formatValue(value, opts);
    }

    formatNumber(value, opts: any = {}): string {
        return this.formatValue(value, opts);
    }

    unformat(value, opts: any = {}) {
        return this._unformat(value, opts);
    }

    /** 获取最大值 */
    max(n1: any, n2 = null) {
        if (Array.isArray(n1)) {
            return BigNumber.max.apply(null, n1).toFixed();
        } else {
            if (n1 && n2) {
                return BigNumber.maximum(n1, n2).toFixed();
            } else {
                console.error(`请提供比较的值n1、n2.`);
            }
        }
    }

    /** 最小值 */
    min(n1: any, n2 = null) {
        if (Array.isArray(n1)) {
            return BigNumber.min.apply(null, n1).toFixed();
        } else {
            if (n1 && n2) {
                return BigNumber.minimum(n1, n2).toFixed();
            } else {
                console.error(`请提供比较的值n1、n2.`);
            }
        }
    }

    /** 求和 */
    sum(n1: NumberType[]) {
        return BigNumber.sum.apply(null, n1).toFixed();
    }

    /** 平均数 */
    avg(n1: NumberType, len: number) {
        return new BigNumber(n1).div(len).toFixed();
    }

    /**  加法 */
    plus(n1: NumberType, n2: NumberType) {
        return new BigNumber(n1).plus(n2).toFixed();
    }

    /** 乘法 */
    multiplied(n1: NumberType, n2: NumberType) {
        new BigNumber(n1).times(n2).toFixed();
    }

    /** 减法 */
    minus(n1: NumberType, n2: NumberType) {
        return new BigNumber(n1).minus(n2).toFixed();
    }

    /** 是否相等 */
    eq(n1: NumberType, n2: NumberType): boolean {
        return new BigNumber(n1).eq(n2);
    }

    lt(n1: NumberType, n2: NumberType): boolean {
        return new BigNumber(n1).lt(n2);
    }
    gt(n1: NumberType, n2: NumberType): boolean {
        return new BigNumber(n1).gt(n2);
    }

    toNumber(n1: string) {
        return new BigNumber(n1).toNumber();
    }

    toFixed(n1: string, precision: number = 0) {
        return new BigNumber(n1).toFixed(precision);
    }

    convertCurrency(money) {
        // 汉字的数字
        const cnNums = new Array('零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖');
        // 基本单位
        const cnIntRadice = new Array('', '拾', '佰', '仟');
        // 对应整数部分扩展单位
        const cnIntUnits = new Array('', '万', '亿', '兆');
        // 对应小数部分单位
        const cnDecUnits = new Array('角', '分', '毫', '厘');
        // 整数金额时后面跟的字符
        const cnInteger = '整';
        // 整型完以后的单位
        const cnIntLast = '元';
        // 最大处理的数字
        const maxNum = 999999999999999.9999;
        // 金额整数部分
        let integerNum;
        // 金额小数部分
        let decimalNum;
        // 输出的中文金额字符串
        let chineseStr = '';
        // 分离金额后用的数组，预定义
        let parts;
        if (money == '') { return ''; }
        money = parseFloat(money);
        if (money >= maxNum) {
            // 超出最大处理数字
            return '';
        }
        if (money === 0) {
            chineseStr = cnNums[0] + cnIntLast + cnInteger;
            return chineseStr;
        }
        // 转换为字符串
        money = money.toString();
        if (money.indexOf('.') === -1) {
            integerNum = money;
            decimalNum = '';
        } else {
            parts = money.split('.');
            integerNum = parts[0];
            decimalNum = parts[1].substr(0, 4);
        }
        // 获取整型部分转换
        if (parseInt(integerNum, 10) > 0) {
            let zeroCount = 0;
            const IntLen = integerNum.length;
            for (let i = 0; i < IntLen; i++) {
                const n = integerNum.substr(i, 1);
                const p = IntLen - i - 1;
                const q = p / 4;
                const m = p % 4;
                if (n == '0') {
                    zeroCount++;
                } else {
                    if (zeroCount > 0) {
                        chineseStr += cnNums[0];
                    }
                    // 归零
                    zeroCount = 0;
                    chineseStr += cnNums[parseInt(n, 10)] + cnIntRadice[m];
                }
                if (m == 0 && zeroCount < 4) {
                    chineseStr += cnIntUnits[q];
                }
            }
            chineseStr += cnIntLast;
        }
        // 小数部分
        if (decimalNum !== '') {
            const decLen = decimalNum.length;
            for (let i = 0; i < decLen; i++) {
                let n = decimalNum.substr(i, 1);
                if (n !== '0') {
                    chineseStr += cnNums[Number(n)] + cnDecUnits[i];
                }
            }
        }
        if (chineseStr === '') {
            chineseStr += cnNums[0] + cnIntLast + cnInteger;
        } else if (decimalNum === '') {
            chineseStr += cnInteger;
        }
        return chineseStr;

    }

    private _unformat(val, opts) {
        val = (val === null || val === undefined || isNaN(val)) ? '' : String(val);
        if (opts) {
            // 去前缀
            if (opts.prefix) {
                val = val.replace(new RegExp(opts.prefix, 'g'), '');
            }

            // 去后缀
            if (opts.suffix) {
                val = val.replace(new RegExp(opts.suffix, 'g'), '');
            }

            // 去掉千分位分隔符
            val = val.replace(/\,/g, '');
        }
        return val;
    }

    private formatValue(value, opts: any) {
        const bignum = new BigNumber(value);
        const fmt = {
            prefix: opts.prefix || '',
            suffix: opts.suffix || '',
            decimalSeparator: opts.decimal || '.',
            groupSeparator: opts.thousand || '',
            groupSize: 3
        };

        if (bignum.isNaN()) {
            return '';
        }

        let precision = opts.precision || 0;
        precision = Number(precision);

        return bignum.toFormat(precision, fmt);
    }
}