package com.skua.modules.util;

import cn.hutool.core.util.NumberUtil;
import com.skua.core.util.ConvertUtils;
import com.skua.modules.report.entity.FReportItem;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

public class ReportUtil {
    /**
     * 计算加权平均，权重固定为‘今日处理水量’
     * @param everyDayList 每天的数据
     * @param keys 要计算 加权平均 的key
     * @return Map<key, 加权平均值>
     */
    public static Map<String, BigDecimal> calWeighAvg(List<Map> everyDayList, String ... keys) {
        //水质key, 累计值
        Map<String, BigDecimal> accValueMap = new HashMap<>();
        for (String key : keys) {
            //数据初始化
            accValueMap.put(key, BigDecimal.ZERO);
        }
        //累计水量
        BigDecimal totalSl = BigDecimal.ZERO;

        for (Map dayData : everyDayList) {
            //今日水量
            BigDecimal sl = dayData.get("今日水处理量") == null || StringUtils.isBlank(dayData.get("今日水处理量").toString()) ? null : new BigDecimal(dayData.get("今日水处理量").toString());
            if(sl == null || sl.compareTo(BigDecimal.ZERO) == 0){
                continue;
            }
            totalSl = NumberUtil.add(totalSl, sl);

            for (String key : keys) {
                //COD*水量
                BigDecimal value = dayData.get(key) == null || !NumberUtil.isNumber(dayData.get(key).toString()) ? null : new BigDecimal(dayData.get(key).toString());
                BigDecimal mulValue = NumberUtil.mul(value, sl);
                accValueMap.put(key, NumberUtil.add(accValueMap.get(key), mulValue));
            }
        }

        if(totalSl.compareTo(BigDecimal.ZERO) == 0){
            //累计水量为0，直接返回
            return accValueMap;
        }

        for (Map.Entry<String, BigDecimal> entry : accValueMap.entrySet()) {
            // value / 权重
            entry.setValue(NumberUtil.round(NumberUtil.div(entry.getValue(), totalSl), 2));
        }
        return accValueMap;
    }

    /**
     * sum
     * @param allValueMap  同一个key的数据，汇总到一起
     * @param key
     * @return 0 or 计算的值，不会返回null
     */
    public static BigDecimal calSumValue(Map<String, List<BigDecimal>> allValueMap, String key) {
        return NumberUtil.add(Optional.ofNullable(allValueMap.get(key)).orElse(new LinkedList<>()).toArray(new BigDecimal[0]));
    }

    /**
     * max
     * @param allValueMap  同一个key的数据，汇总到一起
     * @param key
     * @return 0 or 计算的值，不会返回null
     */
    public static BigDecimal calMaxValue(Map<String, List<BigDecimal>> allValueMap, String key) {
        if (CollectionUtils.isEmpty(allValueMap.get(key))) {
            return null;
        }
        return NumberUtil.max(Optional.ofNullable(allValueMap.get(key)).orElse(new LinkedList<>()).toArray(new BigDecimal[0]));
    }

    /**
     * min
     * @param allValueMap  同一个key的数据，汇总到一起
     * @param key
     * @return 0 or 计算的值，不会返回null
     */
    public static BigDecimal calMinValue(Map<String, List<BigDecimal>> allValueMap, String key) {
        if (CollectionUtils.isEmpty(allValueMap.get(key))) {
            return null;
        }
        return NumberUtil.min(Optional.ofNullable(allValueMap.get(key)).orElse(new LinkedList<>()).toArray(new BigDecimal[0]));
    }

    /**
     * max（包含小于符号）
     * @param notLessThanMonthValueMap  同一个key的数据，汇总到一起 （不包含小于符号的数据）
     * @param lessThanValueMap  同一个key的数据，汇总到一起 包含【小于符号】的值,但会去掉小于符号
     * @param key
     * @return 0 or 计算的值，不会返回null
     */
    public static String calMaxValueContainsLessThan(Map<String, List<BigDecimal>> notLessThanMonthValueMap,Map<String, List<BigDecimal>> lessThanValueMap, String key) {
        //最大值（不包含小于符号的数据)
        BigDecimal maxInNotLessValue = null;
        if (CollectionUtils.isNotEmpty(notLessThanMonthValueMap.get(key))) {
            maxInNotLessValue = NumberUtil.max(Optional.ofNullable(notLessThanMonthValueMap.get(key)).orElse(new LinkedList<>()).toArray(new BigDecimal[0]));
        }


        if(CollectionUtils.isNotEmpty(lessThanValueMap.get(key))){
            //最大值（在所有的包含'<'数据中)
            BigDecimal maxInLessThanValue = NumberUtil.max(Optional.ofNullable(lessThanValueMap.get(key)).orElse(new LinkedList<>()).toArray(new BigDecimal[0]));

            if(maxInLessThanValue == null){
                return maxInNotLessValue == null ? "" : maxInNotLessValue.toPlainString();
            }

            if(maxInNotLessValue == null || maxInLessThanValue.compareTo(maxInNotLessValue) > 0){
                return "<" + maxInLessThanValue.toPlainString();
            }
        }

        return maxInNotLessValue == null ? "" : maxInNotLessValue.toPlainString();
    }

    /**
     * min（包含小于符号）
     * @param allValueMap  同一个key的数据，汇总到一起 （所有的数据）
     * @param lessThanValueMap  同一个key的数据，汇总到一起 包含【小于符号】的值
     * @param key
     * @return 0 or 计算的值，不会返回null
     */
    public static String calMinValueContainsLessThan(Map<String, List<BigDecimal>> allValueMap, Map<String, List<BigDecimal>> lessThanValueMap, String key) {
        if (CollectionUtils.isEmpty(allValueMap.get(key))) {
            return null;
        }
        //最小值（在所有的数据中)
        BigDecimal minInAllValue = NumberUtil.min(Optional.ofNullable(allValueMap.get(key)).orElse(new LinkedList<>()).toArray(new BigDecimal[0]));

        if(CollectionUtils.isNotEmpty(lessThanValueMap.get(key))){
            //最小值（在所有的包含'<'数据中)
            BigDecimal minInLessThanValue = NumberUtil.min(Optional.ofNullable(lessThanValueMap.get(key)).orElse(new LinkedList<>()).toArray(new BigDecimal[0]));

            if(minInLessThanValue != null && minInLessThanValue.compareTo(minInAllValue) <= 0){
                return "<" + minInLessThanValue.toPlainString();
            }
        }

        return minInAllValue.toPlainString();

    }

    /**
     * 计算平均值
     * @param allValueMap  同一个key的数据，汇总到一起
     * @param key
     * @return 0 or 计算的值，不会返回null
     */
    public static BigDecimal calAvgValue(Map<String, List<BigDecimal>> allValueMap, String key) {
        return calAvgValue(allValueMap, key, 4);
    }
    /**
     * 计算平均值
     * @param allValueMap  同一个key的数据，汇总到一起
     * @param key
     * @return 0 or 计算的值，不会返回null
     */
    public static BigDecimal calAvgValue(Map<String, List<BigDecimal>> allValueMap, String key, int scale) {
        BigDecimal avgValue;
        List<BigDecimal> valueList = Optional.ofNullable(allValueMap.get(key)).orElse(new LinkedList<>());
        if (CollectionUtils.isNotEmpty(valueList)) {
            double sum = NumberUtil.add(valueList.toArray(new BigDecimal[0])).doubleValue();
            avgValue = ReportUtil.div(sum, valueList.size());

            avgValue = NumberUtil.round(avgValue ,scale);
        } else {
            avgValue = null;
        }

        return avgValue;
    }

    /**
     * 同一个key的数据，汇总到一起
     * 非数字的值将被忽略（null 空字符串 非法数字）
     * 去掉<
     * @param everyDayReportList
     * @return
     */
    public static Map<String, List<BigDecimal>> valueListGroupByKey(List<Map> everyDayReportList) {
        Map<String, List<BigDecimal>> allValueMap = new HashMap();
        for (Map<String,Object> dayData : everyDayReportList) {
            for (Map.Entry<String, Object> entry : dayData.entrySet()) {
                Object value = entry.getValue();
                String key = entry.getKey();
                if (!allValueMap.containsKey(key)) {
                    allValueMap.put(key, new LinkedList<>());
                }

                if(value == null || StringUtils.isBlank(value.toString())){
                    continue;
                }
                //客户要求支持填写 '<'
                String valueString = value.toString().replaceAll("\\<", "").replaceAll("＜", "").trim();

                if(NumberUtil.isNumber(valueString)){
                    List<BigDecimal> valueList = allValueMap.get(key);
                    valueList.add(new BigDecimal(valueString));
                }
            }
        }
        return allValueMap;
    }

    /**
     * 只获取【包含小于符号】的值，但是返回的值会把小于符号去掉
     * @param everyDayReportList
     * @return
     */
    public static Map<String, List<BigDecimal>> lessThanValueListGroupByKey(List<Map> everyDayReportList) {
        Map<String, List<BigDecimal>> allValueMap = new HashMap();
        for (Map<String,Object> dayData : everyDayReportList) {
            for (Map.Entry<String, Object> entry : dayData.entrySet()) {
                Object value = entry.getValue();
                String key = entry.getKey();
                if (!allValueMap.containsKey(key)) {
                    allValueMap.put(key, new LinkedList<>());
                }

                if(value == null || StringUtils.isBlank(value.toString())){
                    continue;
                }
                if(!(value.toString().startsWith("<") || value.toString().startsWith("＜"))){
                    continue;
                }
                //去掉 '<'
                String valueString = value.toString().replaceAll("\\<", "").replaceAll("＜", "").trim();

                if(NumberUtil.isNumber(valueString)){
                    List<BigDecimal> valueList = allValueMap.get(key);
                    valueList.add(new BigDecimal(valueString));
                }
            }
        }
        return allValueMap;
    }


    /**
     * 只获取【不包含小于符号】的值
     * @param everyDayReportList
     * @return
     */
    public static Map<String, List<BigDecimal>> notLessThanValueListGroupByKey(List<Map> everyDayReportList) {
        Map<String, List<BigDecimal>> allValueMap = new HashMap();
        for (Map<String,Object> dayData : everyDayReportList) {
            for (Map.Entry<String, Object> entry : dayData.entrySet()) {
                Object value = entry.getValue();
                String key = entry.getKey();
                if (!allValueMap.containsKey(key)) {
                    allValueMap.put(key, new LinkedList<>());
                }

                if(value == null || StringUtils.isBlank(value.toString())){
                    continue;
                }
                if((value.toString().startsWith("<") || value.toString().startsWith("＜"))){
                    continue;
                }
                String valueString = value.toString().trim();

                if(NumberUtil.isNumber(valueString)){
                    List<BigDecimal> valueList = allValueMap.get(key);
                    valueList.add(new BigDecimal(valueString));
                }
            }
        }
        return allValueMap;
    }


    /**
     * 对于包含【小于符号】的值，返回的值会替换成0
     * @param everyDayReportList
     * @return
     */
    public static Map<String, List<BigDecimal>> lessThanValueToZeroListGroupByKey(List<Map> everyDayReportList) {
        Map<String, List<BigDecimal>> allValueMap = new HashMap();
        for (Map<String,Object> dayData : everyDayReportList) {
            for (Map.Entry<String, Object> entry : dayData.entrySet()) {
                Object value = entry.getValue();
                String key = entry.getKey();
                if (!allValueMap.containsKey(key)) {
                    allValueMap.put(key, new LinkedList<>());
                }

                if(value == null || StringUtils.isBlank(value.toString())){
                    continue;
                }

                String valueString = value.toString();
                if(value.toString().startsWith("<") || value.toString().startsWith("＜")){
                    valueString = "0";
                }

                if(NumberUtil.isNumber(valueString)){
                    List<BigDecimal> valueList = allValueMap.get(key);
                    valueList.add(new BigDecimal(valueString));
                }
            }
        }
        return allValueMap;
    }

    /**
     * 同一个key的数据，汇总到一起
     * 非数字的值将被忽略（null 空字符串 非法数字）
     * @param everyDayReportList
     * @return
     */
    public static Map<String, List<BigDecimal>> valueListGroupByKey1(List<Map<String, Object>> everyDayReportList) {
        return valueListGroupByKey(transformListMap(everyDayReportList));
    }



    public static List<Map> transformListMap(List<Map<String, Object>> list){
        List<Map> returnData = new LinkedList<>();
        returnData.addAll(list);
        return returnData;
    }


    /**
     * 多个数据集，合并每天的数据
     *
     * @param startTime yyyy-MM-dd
     * @param endTime
     * @param dataList 各个数据集（报表数据必须包含key为time的日期）
     * @return
     */
    public static List<Map> mergeEveryDayData(String startTime, String endTime, List<Map>... dataList){
        List<Map<String, Map>> mapList = new LinkedList<>();
        for (List<Map> maps : dataList) {
            //Map<日期, 报表数据>  报表数据必须包含key为time的日期 否则可能报错：IllegalStateException: Duplicate key
            for (Map map : maps) {
                Object time = map.get("time");
                System.out.println();
            }
            Map<String, Map> mapByTime = maps.stream().collect(Collectors.toMap(m -> (String) m.get("time"), po -> po));
            mapList.add(mapByTime);
        }

        LocalDate startLocalDate = LocalDate.parse(startTime);
        LocalDate endLocalDate = LocalDate.parse(endTime).plusDays(1);
        List<Map> returnData = new LinkedList<>();
        int index = 1;
        while(startLocalDate.compareTo(endLocalDate) < 0){
            String currentDate = startLocalDate.format(DateTimeFormatter.ISO_LOCAL_DATE);
            Map map = new HashMap();
            for (Map<String, Map> reportDataMap : mapList) {
                map.putAll(reportDataMap.getOrDefault(currentDate, new HashMap<>()));
            }
            map.put("time", currentDate);
            map.put("序号", index++);
            returnData.add(map);

            startLocalDate = startLocalDate.plusDays(1);
        }
        return returnData;
    }



    /**
     * 计算每天电量
     * @param startTime
     * @param endTime
     * @param xjReportData 巡检填报 原始数据
     * @return
     */
    public static List<Map> calEveryDayDlData(String startTime, String endTime, List<Map<String, Object>> xjReportData){

        Map<String, Map<String, Object>> xjReportDataMap = xjReportData.stream().collect(Collectors.toMap(m -> (String) m.get("time"), po -> po));

        LocalDate startLocalDate = LocalDate.parse(startTime);
        LocalDate endLocalDate = LocalDate.parse(endTime).plusDays(1);
        List<Map> returnData = new LinkedList<>();
        while(startLocalDate.compareTo(endLocalDate) < 0) {
            String currentDate = startLocalDate.format(DateTimeFormatter.ISO_LOCAL_DATE);

            Map dataMap = new HashMap();
            dataMap.put("time", currentDate);
            returnData.add(dataMap);

            if (xjReportDataMap.containsKey(currentDate)) {
                dataMap.put("今日电量", String.valueOf(ReportUtil.getBigDecimalValue("MRDL", xjReportDataMap.get(currentDate))));
            }



            startLocalDate = startLocalDate.plusDays(1);
        }

        return returnData;
    }

    private static String generateKey(String time, String departId){
        return departId + "_" + time;
    }


    /**
     * key翻译成中文
     * @param oldMap
     * @param attributeList
     * @return
     */
    public static Map<String, Object> transformKey(Map<String, Object> oldMap, List<FReportItem> attributeList) {
        Map<String, FReportItem> reportItemMap = attributeList.stream().collect(Collectors.toMap(FReportItem::getItemCode, po -> po));
        Map<String, Object> newMap = new LinkedHashMap<>();
        for (String key : oldMap.keySet()) {
            String newKey = key;
            if(reportItemMap.containsKey(key)){
                newKey = reportItemMap.get(key).getItemAlias();
            }
            newMap.put(newKey, oldMap.get(key));
        }
        return newMap;
    }

    /**
     * 计算加权平均
     * (a1*b1 + a2*b2)/ (b1+b2)
     * @param dataList
     * @param a1
     * @param b1
     * @param a2
     * @param b2
     * @param key 新数据key （结果将会被保存到Map中）
     */
    public static void calWeightAvg(List<Map> dataList, String a1, String b1, String a2, String b2, String key) {
        //(a1*b1 + a2*b2)/ (b1+b2)
        for (Map map : dataList) {
            BigDecimal value = null;
            BigDecimal a1value = getBigDecimalValue(a1, map);
            BigDecimal b1value = getBigDecimalValue(b1, map);
            BigDecimal a2value = getBigDecimalValue(a2, map);
            BigDecimal b2value = getBigDecimalValue(b2, map);

            // (b1+b2)
            BigDecimal b1AddB2 = NumberUtil.add(b1value, b2value);

            if(b1AddB2.compareTo(BigDecimal.ZERO) == 0){
                value = null;
            } else {
                //有bug：NumberUtil.mul(30, null) = 30 ,而不是期望的0
                BigDecimal a1MulB1 = (a1value == null || b1value == null) ? null : ReportUtil.mul(a1value, b1value);
                BigDecimal a2MulB2 = (a2value == null || b2value == null) ? null : ReportUtil.mul(a2value, b2value);

                value = ReportUtil.div(ReportUtil.add(a1MulB1, a2MulB2), b1AddB2);
            }

            map.put(key, value);
        }
    }
    /**
     * 计算加权平均
     * （key1*weight1 + key2*weight2 + keyN*weightN) / sum (weight1+weight2+weightN）
     * @param dataList
     * @param valueKey
     * @param weightKey
     * @param valueKey 新数据key （结果将会被保存到Map中）
     */
    public static BigDecimal calTotalWeightAvgAB(List<Map> dataList, String weightKey, String valueKey, Integer scale) {
        BigDecimal total = BigDecimal.ZERO;
        BigDecimal totalWeight = BigDecimal.ZERO;
        scale = scale == null ? 4 : scale;//默认4位小数

        for (Map map : dataList) {

            BigDecimal keyValue = getBigDecimalValue(valueKey, map);
            BigDecimal weightValue = getBigDecimalValue(weightKey, map);
            if(keyValue == null || keyValue.compareTo(BigDecimal.ZERO) == 0 || weightValue == null || weightValue.compareTo(BigDecimal.ZERO) == 0 ){
                continue;
            }

            total = NumberUtil.add(total, NumberUtil.mul(keyValue , weightValue));

            totalWeight = NumberUtil.add(totalWeight, weightValue);

        }

        if (totalWeight.compareTo(BigDecimal.ZERO) == 0) {
            return null;//返回null
        } else {
            return NumberUtil.round(NumberUtil.div(total, totalWeight), scale);
        }
    }


    public static BigDecimal getBigDecimalValue(String a1, Map map) {
        if(map == null){
            return null;
        }
        Object value = map.get(a1);
        if(value == null || StringUtils.isBlank(value.toString())){
            return null;
        }
        //客户要求支持填写 '<'
        String valueString = value.toString().replaceAll("\\<", "").replaceAll("＜", "").trim();

        return !NumberUtil.isNumber(valueString) ? null : new BigDecimal(valueString);
    }

    public static void main(String[] args) {
        System.out.println(roundContainsEndZero(1, 2));

        List<Map<String, Object>> monthReportData = new LinkedList<>();

//        Map<String, Object> map1 = new HashMap<>();
//        map1.put("java", "0.1");
//        monthReportData.add(map1);
//        Map<String, Object> map2 = new HashMap<>();
//        map2.put("java", "0.2");
//        monthReportData.add(map2);

        System.out.println("=======");
        System.out.println(calMaxValueContainsLessThan(notLessThanValueListGroupByKey(transformListMap(monthReportData)),
                lessThanValueListGroupByKey(transformListMap(monthReportData)), "java"));


        Map<String, Object> map3 = new HashMap<>();
        map3.put("java", "<0.1");
        monthReportData.add(map3);
        Map<String, Object> map4 = new HashMap<>();
        map4.put("java", "<0.3");
        monthReportData.add(map4);

        System.out.println("=======");
        System.out.println(calMaxValueContainsLessThan(notLessThanValueListGroupByKey(transformListMap(monthReportData)),
                lessThanValueListGroupByKey(transformListMap(monthReportData)), "java"));


        Map<String, Object> map5 = new HashMap<>();
        map5.put("java", "<10");
        monthReportData.add(map5);
        Map<String, Object> map6 = new HashMap<>();
        map6.put("java", "10");
        monthReportData.add(map6);

        System.out.println("=======");
        System.out.println(calMaxValueContainsLessThan(notLessThanValueListGroupByKey(transformListMap(monthReportData)),
                lessThanValueListGroupByKey(transformListMap(monthReportData)), "java"));




        double number = 3.1415926;
        DecimalFormat df = new DecimalFormat("#.##");
        String formattedNumber = df.format(number);

//        System.out.println(df.format(0d));
//        System.out.println(df.format(0.0d));
//        System.out.println(df.format(0.666d));

//        System.out.println(round(0d, 0));
//        System.out.println(round(0.1001d, 2));
//        System.out.println(round(0.0001d, 1));
//        System.out.println(round(111.555d, 1));
//        System.out.println(round(1.455d, 2));
//        System.out.println(round(1.555d, 2));
//        System.out.println(round(111.555d, 3));

    }

    /**
     * 数字格式化，保留小数位，并会去掉末尾0
     * 有bug：1.455d=》1.46 ； 1.555d 》 1.55
     * @param value
     * @param scale 小数位数
     * @return
     */
    @Deprecated
    public static String format(double value, int scale){
        StringBuilder sb = new StringBuilder("#");
        if(scale > 0){
            sb.append(".");
            for (int i = 0; i < scale; i++) {
                sb.append("#");
            }
        }

        DecimalFormat df = new DecimalFormat(sb.toString());

        return df.format(value);
    }
    /**
     * 数字格式化，保留小数位，并会去掉末尾0
     * @param value
     * @param scale 小数位数
     * @return
     */
    public static String roundForDouble(double value, int scale){
//        return NumberUtil.round(value,scale).toString().replaceAll("\\.?0*$", "");
        return NumberUtil.round(value,scale).stripTrailingZeros().toPlainString();
    }

    /**
     * 乘法
     * @param a1value
     * @param b1value
     * @return
     */
    public static BigDecimal mul(Number a1value, Number b1value){
        //NumberUtil.mul(30, null) = 30 ,而不是期望的0
        return  (a1value == null || b1value == null) ? null : NumberUtil.mul(a1value, b1value);
    }

    /**
     * add
     * @param a1value
     * @param b1value
     * @return
     */
    public static BigDecimal add(Number a1value, Number b1value){
        //NumberUtil.add(null, null) = 0 ,而不是期望的null
        return  (a1value == null && b1value == null) ? null : NumberUtil.add(a1value, b1value);
    }

    /**
     * 除法
     * @param a1value
     * @param b1value
     * @return
     */
    public static BigDecimal div(Number a1value, Number b1value){
        //NumberUtil.div(null, 1) 会出现空指针异常
        return  (a1value == null || b1value == null || new BigDecimal(b1value.toString()).compareTo(BigDecimal.ZERO) == 0) ? null : NumberUtil.div(a1value, b1value);
    }

    /**
     * 保留小数位，并会去掉末尾0，规避科学计数法
     * @param value
     * @param scale
     * @return
     */
    public static BigDecimal round(Number value, int scale){
        //NumberUtil.round(null) 会返回0,这不合理，并且不会舍弃小数点后的末尾0
        if (value == null) {
            return null;
        }
        //stripTrailingZeros：可以去掉末尾0，但是可能会返回科学计数法，比如10：1E+2
        //.toPlainString() : 返回非科学技术法的字符串表示
        return  new BigDecimal(NumberUtil.round(new BigDecimal(value.toString()), scale).stripTrailingZeros().toPlainString());
    }
    /**
     * 保留小数位，[不会]去掉末尾0，规避科学计数法
     * @param value
     * @param scale
     * @return
     */
    public static BigDecimal roundContainsEndZero(Number value, int scale){
        //NumberUtil.round(null) 会返回0,这不合理，并且不会舍弃小数点后的末尾0
        if (value == null) {
            return null;
        }
        //stripTrailingZeros：可以去掉末尾0，但是可能会返回科学计数法，比如10：1E+2
        //.toPlainString() : 返回非科学技术法的字符串表示
        return  new BigDecimal(NumberUtil.round(new BigDecimal(value.toString()), scale).toPlainString());
    }

    /**
     * 保留小数位，[不会]去掉末尾0，规避科学计数法
     * @param value
     * @param scale
     * @return
     */
    public static String roundStringContainsEndZero(Number value, int scale){
        //NumberUtil.round(null) 会返回0,这不合理，并且不会舍弃小数点后的末尾0
        if (value == null) {
            return null;
        }
        //stripTrailingZeros：可以去掉末尾0，但是可能会返回科学计数法，比如10：1E+2
        //.toPlainString() : 返回非科学技术法的字符串表示
        return  NumberUtil.round(new BigDecimal(value.toString()), scale).toPlainString();
    }

    /**
     * 四舍五入 并会去掉末尾0，规避科学计数法（包含小于符号的返回原值）
     * @param value
     * @param scale
     * @return
     */
    public static String roundForContainsLessThan(String value, int scale){
        if (StringUtils.isBlank(value)) {
            return null;
        }
        if(value.startsWith("<") || value.startsWith("＜")){
            //包含小于符号：返回原值
           return value;
        }
        //stripTrailingZeros：可以去掉末尾0，但是可能会返回科学计数法，比如10：1E+2
        //.toPlainString() : 返回非科学技术法的字符串表示
        return  NumberUtil.round(new BigDecimal(value), scale).stripTrailingZeros().toPlainString();
    }
    /**
     * 四舍五入 去掉末尾0，规避科学计数法（返回字符串）
     * @param value
     * @param scale
     * @return
     */
    public static String roundToString(Number value, int scale){
        if (value == null) {
            return null;
        }
        return NumberUtil.round(new BigDecimal(value.toString()), scale).stripTrailingZeros().toPlainString();
    }

    /**
     * 字符串转为数字
     * @param s
     * @return
     */
    public static BigDecimal strToDecimal(String s){
        if (s == null) {
            return null;
        } else {
            try {
                return new BigDecimal(s);
            } catch (Exception e) {
                return null;
            }
        }
    }

    public static BigDecimal newBigDecimal(String value, BigDecimal defaultValue){
        if(value!= null && NumberUtil.isNumber(value)){
            return new BigDecimal(value);
        }
        return defaultValue;
    }

}