/**
 * @Author ygy
 * @Description //TODO 大数据计算工具
 * @Date 16:20 2019/10/31
 * @Param
 * @return
 **/
var Decimal = function (num) {
    num = num + "";
    var regSz = RegExp(/^0+(\.[0]+)?$/); // 判断是否有0.00
    if (regSz.test(num) || num == undefined || num == "undefined" || !num || num == "" || num == "''") {
        num = "0.00";
    }
    num = num.replace(" ", "");
    newObject();
    return new BigDecimal(num + "");
};

/**
 * @Author ygy
 * @Description //TODO 比较俩数大小,四舍五入处理
 * @Date 15:33 2019/11/4
 * @Param expression  d*e+f 表达式 float 2 保留几位小数  round四舍五入
 * @return  -1 小于   0 等于    1 大于
 **/
var copmpareTo = function (first, second, checkType, notYsBz) {
    first = first + "";
    second = second + "";
    var handerFirst = first;
    var handerSecond = second;
    // 如果开头是负数或者正数，比如-1.23，--1.23,，则去除最前面的字符，然后判断这个值是否包含其他的运算符
    if (handerFirst.indexOf("--") == 0) {
        handerFirst = handerFirst.substring(handerFirst.indexOf("--") + 1)
    } else if (handerFirst.indexOf("-") == 0) {
        handerFirst = handerFirst.substring(handerFirst.indexOf("-") + 1)
    }

    if (handerSecond.indexOf("--") == 0) {
        handerSecond = handerSecond.substring(handerSecond.indexOf("--") + 1)
    } else if (handerSecond.indexOf("-") == 0) {
        handerSecond = handerSecond.substring(handerSecond.indexOf("-") + 1)
    }

    var reg = RegExp(/\+\-|\-\-|\*\-|\/\-|\+|\-|\*|\//g);
// 2020-6-10 如果公式，则需要进行公式计算处理，纯小数对比，则直接进行计算结果
    if (reg.test(handerFirst)) {
        // 先算乘除后算加减
        first = multiplyAndDivideFirst(first, checkType) + "";
    }
    if (reg.test(handerSecond)) {
        second = multiplyAndDivideFirst(second, checkType) + "";
    }

    if (notYsBz == "Y") {
        return first
    }

    // 如果其中一个是整数，则整数要补上小数位置
    if (first.indexOf(".") < 0 && second.indexOf(".") >= 0) {
        // 如果只为空，则附上默认值
        if (first == '' || first == "" || first == "''") {
            first = "0";
        }
        first = Number(first).toFixed(second.substring(second.indexOf(".") + 1).length)
    } else if (second.indexOf(".") < 0 && first.indexOf(".") >= 0) {
        // 如果只为空，则附上默认值
        if (second == '' || second == "" || second == "''") {
            second = "0";
        }
        second = Number(second).toFixed(first.substring(first.indexOf(".") + 1).length)
    }
    // 小数精度处理后计算结果 2020-3-13
    var result = decimalPrecisionProcessing(first, second, checkType);
    return result;
};

/**
 * <p>
 * 先算乘除，后算加减
 * </p>
 * @param value,num,round
 * @return
 * @throws
 * @author DyLuo
 * @date 2020/4/9 13:59
 */
function multiplyAndDivideFirst(value, checkType) {
    var formula = value;
    var num = 10;
    var round = false;
    if (checkType == "003" && value.indexOf("/") >= 0) {
        num = 10;
        round = undefined;
    } else if (value.indexOf("/") >= 0) {
        // 2020-3-12 调整 目前除法的表间校验只有任工整理了一条，并且需要设置小数位数，所以暂时所以的除法小数位数设置为精度是4
        num = 4;
        round = undefined;
    }

    var reg = RegExp(/\+\-|\-\-|\+|\-/g); // 把所有特殊符号全部截取
    if (value.indexOf("+") >= 0 && value.indexOf("-") >= 0 && (value.indexOf("*") >= 0 || value.indexOf("/") >= 0)) {
        var fir = value.split(reg);// 先算乘法除法，最后算加减，切割是根据加号减号切割，得到乘法公式或者是除法公式，计算之后，在做加减计算
        $.each(fir, function (index, val) {
            var result = "0";
            if (val.indexOf("/") >= 0) {   // 如果是除法，判断除数是否是0，如果是0，则默认这个除法公式值为0
                var divisor = val.split("/");
                if (divisor.length >= 2) {
                    for (var i = 1; i < divisor.length; i++) {
                        var data = parseFloat(divisor[i]) + "";
                        if (data == "0" || data == '0') {
                            break;
                        }
                    }
                }
            } else {
                result = fourArithmeticOperations(val, num, round);
            }

            value = value.replace(val, result);
        });
    } else if (value.indexOf("/") >= 0) { // 如果是纯除法，则判断下除数是否是0，如果是0，则这个除法公式值是0
        var divisor = value.split("/");
        if (divisor.length >= 2) {
            for (var i = 1; i < divisor.length; i++) {
                var data = parseFloat(divisor[i]) + "";
                if (data == "0" || data == '0') {
                    value = "0";
                    break;
                }
            }
        }
    }

    return fourArithmeticOperations(value, num, round);
    ;
}

/**
 * 小数精度处理后计算结果
 * @param first
 * @param second
 * @param checkType
 * @returns {An<code>}
 */
function decimalPrecisionProcessing(first, second, checkType) {
    first = first + "";
    second = second + "";
    // 若都是小数，则比较的时候，小数位数要相同，以位数少的那个为基准，2020-3-13 添加条件，百分比的小数按照最大的小数位数做比较，所以不会进入一下的小数精度处理中
    if (first.indexOf(".") >= 0 && second.indexOf(".") >= 0 && checkType != '002') {
        var firstLength = first.substring(first.indexOf(".") + 1).length;
        var secondLength = second.substring(second.indexOf(".") + 1).length;
        // 比较小数位数
        if (firstLength > secondLength) {
            // 第1个小数位数长，则四舍五入第1个小数
            first = fourArithmeticOperations(first, secondLength);
        } else if (firstLength < secondLength) {
            // 第2个小数位数长，则四舍五入第2个小数
            second = fourArithmeticOperations(second, firstLength);
        }
    }
    return this.Decimal(first).compareTo(this.Decimal(second));
}


/**
 * @Author ygy
 * @Description //TODO 四则运算
 * @Date 15:33 2019/11/1
 * @Param expression  d*e+f 表达式 float 2 保留几位小数  round四舍五入
 * @return 运算结果
 **/

var fourArithmeticOperations = function (expression, numLength, round) {
    var num = numLength;// 小数位数，四舍五入的时候用的小数位数
    var float = numLength;
    var flag = false; // 第一位是否是负号的标记
    if (expression.indexOf("--") == 0) { // 2020-5-7 如果第一位的数值是--1，处理为正数1
        expression = expression.substring(2, expression.length);
    } else if (expression.indexOf("-") == 0) {  // 如果第一位的数值是-1
        flag = true;
        expression = expression.substring(1, expression.length);
    }
    var _self = this;
    round = round == undefined ? true : false; // 四舍五入控制
    var reg = RegExp(/\+\-|\-\-|\*\-|\/\-|\+|\-|\*|\//g); // 把所有特殊符号全部截取
    var regSz = RegExp(/^(?:0|\-?(?:0\.\d*[0-9]|[0-9]\d*(?:\.\d*[0-9])?))$/);//实数  包括0.000000
    var linshi = "";
    var matchArr = expression.match(reg); //取表达式符号
    var splitArr = expression.split(reg); //取表达式内容
    for (var i = 0; i < splitArr.length; i++) {
        if (!splitArr[i]) {
            splitArr[i] = "0.00"
        }
    }
    $.each(splitArr, function (i, item) {
        var str = item;
        // 浮点位数 取小数位数最大的那个
        if (float < parseInt(item.substring(item.indexOf(".") + 1).length)) {
            float = parseInt(item.substring(item.indexOf(".") + 1).length);
        }
        if (!regSz.test(item)) {
            str = "_self.tableData.pageData." + item;
        }
        if (i == 0) { // 第一位
            float = parseInt(item.substring(item.indexOf(".") + 1).length);
            if (flag) {
                linshi = "-" + item;
            } else {
                linshi = item;
            }
        } else { // 大于第一位
            if (matchArr[i - 1] == "+" || matchArr[i - 1] == "+-") {
                if (round) {
                    linshi = _self.Decimal(linshi).add(_self.Decimal(matchArr[i - 1] == "+-" ? "-" + item : item)).setScale(float + 10, 4).toString();
                } else {
                    linshi = _self.Decimal(linshi).add(_self.Decimal(matchArr[i - 1] == "+-" ? "-" + item : item)).setScale(float + 10).toString();
                }
            } else if (matchArr[i - 1] == "-" || matchArr[i - 1] == "--") {
                if (round) {
                    linshi = _self.Decimal(linshi).subtract(_self.Decimal(matchArr[i - 1] == "--" ? "-" + item : item)).setScale(float + 10, 4).toString();
                } else {
                    linshi = _self.Decimal(linshi).subtract(_self.Decimal(matchArr[i - 1] == "--" ? "-" + item : item)).setScale(float + 10).toString();
                }
            } else if (matchArr[i - 1] == "*" || matchArr[i - 1] == "*-") {
                // 2020-6-28 浮点位数是所有的小数位数加起来的数量
                float = parseInt(float) + parseInt(item.substring(item.indexOf(".") + 1).length);
                if (round) {
                    linshi = _self.Decimal(linshi).multiply(_self.Decimal(matchArr[i - 1] == "*-" ? "-" + item : item)).setScale(float + 10, 4).toString();
                } else {
                    linshi = _self.Decimal(linshi).multiply(_self.Decimal(matchArr[i - 1] == "*-" ? "-" + item : item)).setScale(float + 10).toString();
                }
            } else if (matchArr[i - 1] == "/" || matchArr[i - 1] == "/-") {
                float = num;
                if (round) {
                    linshi = _self.Decimal(linshi).divide(_self.Decimal(matchArr[i - 1] == "/-" ? "-" + item : item), float + 10, 4).toString();
                } else {
                    linshi = _self.Decimal(linshi).divide(_self.Decimal(matchArr[i - 1] == "/-" ? "-" + item : item), float + 10).toString();
                }
            }
        }
    });
    if (round) {
        linshi = this.Decimal(linshi).add(this.Decimal("0")).setScale(num, 4).toString();
    } else {
        linshi = this.Decimal(linshi).add(this.Decimal("0")).setScale(float).toString();
    }
    return linshi;
};



