package com.steerinfo.dil.service.impl;

import com.steerinfo.dil.feign.JoinApiFeign;
import com.steerinfo.dil.feign.OmsFeign;
import com.steerinfo.dil.mapper.BmstruckDetailsOrderMapper;
import com.steerinfo.dil.mapper.OmstruckOrderMapper;
import com.steerinfo.dil.model.BmstruckDetailsOrder;
import com.steerinfo.dil.model.OmstruckOrder;
import com.steerinfo.dil.service.IBmstruckDetailsOrderService;
import com.steerinfo.dil.util.DataChange;
import com.steerinfo.dil.util.EASUtil;
import com.steerinfo.dil.util.NoUtil;
import io.swagger.models.auth.In;
import org.apache.shiro.crypto.hash.Hash;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @Description:
 * @Author:HuJianGuo
 * @GreateTime:2021/9/24 17:34
 * @Version:V2.0
 */
@Service
public class BmstruckDetailsOrderServiceImpl implements IBmstruckDetailsOrderService {

    @Autowired
    BmstruckDetailsOrderMapper bmstruckDetailsOrderMapper;
    @Autowired
    BmstruckFormulaServiceImpl bmstruckFormulaService;
    @Autowired
    NoUtil noUtil;
    @Autowired
    JoinApiFeign joinApiFeign;
    @Autowired
    EASUtil easUtil;
    @Autowired
    OmstruckOrderMapper omstruckOrderMapper;

    @Autowired
    OmsFeign omsFeign;

    //以下订单类型是需要算计量实绩的
    final private List<Integer>  inwardTypeList = Arrays.asList(10,11,15,16,23,24,20,25);
    //以下订单类型是需要根据线路去匹配承运起止范围以及物资
    final private List<Integer>  toLineAndMaterial = Arrays.asList(10,20,23,24);
    //以下订单类型是需要去根据固定承运起止范围以及物资
    final private List<Integer>  fixLineList = Arrays.asList(15,16);
    //以下订单类型是钢材
    final private List<Integer> steelTypeList = Arrays.asList(25);

    /**
     * 展示汽运详单列表
     * @param mapVal
     * @return
     */
    @Override
    public List<Map<String, Object>> getTruckDetailsOrderList(Map<String, Object> mapVal) {
        Integer orderType = (Integer) mapVal.get("orderType");
        List<Map<String, Object>> truckDetailsOrderList;
        if (orderType <= 3 && orderType >= 1) {
            truckDetailsOrderList = bmstruckDetailsOrderMapper.getSaleTruckDetailsOrderList(mapVal);
        }
        else {
            truckDetailsOrderList = bmstruckDetailsOrderMapper.getTruckDetailsOrderList(mapVal);
        }
        return truckDetailsOrderList;
    }

    /**
     * 新增详单
     * @param orderId
     * @return
     */
    @Override
    public int insertSelective(BigDecimal orderId) throws Exception {
        List<Map<String,Object>> weightTaskResultIdList = bmstruckDetailsOrderMapper.getWeightTaskResultId(orderId);
        Map<String,Object> priceMap = getPriceId(orderId);
        if (priceMap == null || priceMap.size() == 0) {
            return 0;
        }
        BigDecimal priceId = (BigDecimal) priceMap.get("priceId");
        if (priceId.intValue() == 0) {
            return 0;
        }
        int result = 0;
        for (Map<String, Object> map : weightTaskResultIdList) {
            BigDecimal weightTaskResultId = DataChange.dataToBigDecimal(map.get("weightTaskResultId"));
            BigDecimal detailsAmountOld = generateTruckFees(orderId, weightTaskResultId);
            Double amount = detailsAmountOld.doubleValue();
            DecimalFormat df = new DecimalFormat("0.00");
            String format = df.format(amount);
            BigDecimal detailsAmount = new BigDecimal(format);
            BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
            BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
            if (orderType.intValue() == 3) {
                BigDecimal purchaseOrderId = getFormulaMembers(orderId);
                bmstruckDetailsOrder.setPurchaseOrderId(purchaseOrderId);
            }
            if (orderType.intValue() == 2 || orderType.intValue() == 1) {
                bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(0));
            }
            // 得到最大id
            BigDecimal detailsId = selectMaxId();
            String detailsNo = noUtil.setResultNo("QYXD", detailsId);
            bmstruckDetailsOrder.setDetailsId(detailsId);
            bmstruckDetailsOrder.setWeightTaskResultId(weightTaskResultId);
            bmstruckDetailsOrder.setDetailsNo(detailsNo);
            bmstruckDetailsOrder.setPriceId(priceId);
            bmstruckDetailsOrder.setDetailsAmount(detailsAmount);
            bmstruckDetailsOrder.setDetailsTime(new Date());
            // 设置常规字段
            bmstruckDetailsOrder.setInsertTime(new Date());
            bmstruckDetailsOrder.setUpdateTime(new Date());
            bmstruckDetailsOrder.setInsertUsername("admin");
            bmstruckDetailsOrder.setUpdateUsername("admin");
            bmstruckDetailsOrder.setInsertUpdateRemark("无");
            result += bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
        }
        return result;
    }

    /**
     * 查询最大id
     * @return
     */
    @Override
    public BigDecimal selectMaxId() {
        return  bmstruckDetailsOrderMapper.selectDetailsId();
    }

    /**
     * 展示汽运实绩列表
     * @param mapVal
     * @return
     */
    @Override
    public List<Map<String, Object>> getTruckResultList(Map<String, Object> mapVal) {
        BigDecimal orderId = (BigDecimal) mapVal.get("orderId") ;
        BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
        List<Map<String,Object>> mapList;
        if (orderType.intValue() <= 3 && orderType.intValue() >= 1) {
            mapList = bmstruckDetailsOrderMapper.getSaleTruckResultList(mapVal);
        }
        else {
            mapList = bmstruckDetailsOrderMapper.getTruckResultList(mapVal);
        }
        return mapList;
    }

    /**
     * 得到计算因子
     * @param orderId
     * @return
     */
    @Override
    public BigDecimal getFormulaMembers(BigDecimal orderId) {
        return bmstruckDetailsOrderMapper.getFormulaMembers(orderId);
    }

    /**
     * 得到价格id
     * @return
     */
    @Override
    public Map<String, Object> getPriceId(BigDecimal orderId) {
        return bmstruckDetailsOrderMapper.getPriceId(orderId);
    }

    /**
     * 得到单价
     * @param priceId
     * @return
     */
    @Override
    public BigDecimal getPriceValue(BigDecimal priceId) {
        return bmstruckDetailsOrderMapper.getPriceValue(priceId);
    }

    /**
     * 得到到厂湿重
     * @param weightTaskResultId
     * @return
     */
    @Override
    public BigDecimal getNetWeight(BigDecimal weightTaskResultId) {
        return bmstruckDetailsOrderMapper.getNetWeight(weightTaskResultId);
    }

    /**
     * 展示未转成销售账单的销售详单
     * @param mapVal
     * @param orderType
     * @return
     */
    @Override
    public List<Map<String, Object>> getUnFinishedTruckDetailsOrderList(Map<String, Object> mapVal, Integer orderType) {
        if (mapVal == null) {
            mapVal = new HashMap<>();
        }
        mapVal.put("orderType",new BigDecimal(orderType));
        return bmstruckDetailsOrderMapper.getUnFinishedTruckDetailsOrderList(mapVal);
    }
    //通过不同的值，查询未生成账单的计费详单
    @Override
    public List<Map<String, Object>> getUnFinishedConvertedTruckDetailsOrderList(Map<String, Object> mapVal, Integer orderType) {
        //orderType:1:计时,2:计数，3：计重，4：包月
        if(orderType==1){
            return bmstruckDetailsOrderMapper.getUnFinishedTimeTruckDetailsOrderList(mapVal);
        }
        else if(orderType==2){
            return bmstruckDetailsOrderMapper.getUnFinishedNumTruckDetailsOrderList(mapVal);
        }
        else if(orderType==3){
            return bmstruckDetailsOrderMapper.getUnFinishedWeightTruckDetailsOrderList(mapVal);
        }
        else if(orderType==4){
            return bmstruckDetailsOrderMapper.getUnFinishedMonthTruckDetailsOrderList(mapVal);
        }
        return null;
    }



    /**
     * 替换汽运费公式并进行计算
     * @param orderId
     * @return
     * @throws Exception
     */
    public BigDecimal generateTruckFees(BigDecimal orderId,BigDecimal weightTaskResultId) throws Exception {
        BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
        Map<String, Object> priceMap = getPriceId(orderId);
        BigDecimal priceId = (BigDecimal) priceMap.get("priceId");
        BigDecimal priceValue = getPriceValue(priceId);
        BigDecimal netWeight = getNetWeight(weightTaskResultId);
        // 得到计费公式
        String formula_string = null;
        if (orderType.intValue() == 3) {
            // 得到采购汽运计费公式
            formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(8));
            // 替换采购汽运运计算公式
            formula_string = formula_string.replace("到厂计量湿吨",netWeight.toString())
                    .replace("单价",priceValue.toString());
        }
        if (orderType.intValue() >= 1 && orderType.intValue() <= 3) {
//            BigDecimal distance = new BigDecimal(101);
            // 得到销售汽运计费公式
//            if (distance.intValue() >= 91 || distance.intValue() <= 109) {
                // 得到销售10km差距内的汽运计费公式
                formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(10));
                // 替换采购汽运运计算公式
                formula_string = formula_string.replace("运输单价",priceValue.toString())
                        .replace("物资净重",netWeight.toString());
//            }
//            else {
//                // 得到销售10km差距外的汽运计费公式
//                formula_string = bmstruckFormulaService.getTruckFormula(new BigDecimal(11));
//                // 替换采购汽运运计算公式
//                formula_string = formula_string.replace("运输单价",priceValue.toString())
//                        .replace("运输距离",distance.toString())
//                        .replace("物资净重",netWeight.toString());
//            }
        }
        String s = toSufExpr(formula_string);
        return calSufExpr(s);
    }

    /**
     * 中缀转换后缀表达式
     */
    public  String toSufExpr(String s) {
        StringBuffer sufExpr = new StringBuffer();
        Stack<String> stack = new Stack<>();
        //压入空方便判断
        stack.push(null);
        Pattern pattern = Pattern.compile("\\(int\\)|(?<!\\d|[)])-?\\d+(\\.\\d+)?|!=|>=|<=|==|[+\\-*/%()><=|]");
        Matcher matcher = pattern.matcher(s);
        while (matcher.find()) {
            String group = matcher.group();
            if (group.matches("!=|>=|<=|==|[+\\-*/%()><=|]|\\(int\\)")) {//是运算符
                if (group.equals("(")) {//之间压栈
                    stack.push(group);
                } else if (group.equals(")")) {//等于右括号，一直弹栈，直到遇到左括号
                    String pop = null;
                    while (!(pop = stack.pop()).equals("(")) {//遍历循环至左括号
                        sufExpr.append(pop + " ");
                    }
                } else {//是运算符：加减乘除强转，根据优先级压栈
                    while (getPriority(group) <= getPriority(stack.peek())) {
                        String pop = stack.pop();
                        System.out.println(pop);
                        System.out.println(sufExpr);
                        if(pop!=null&&!pop.equals("|")){
                            sufExpr.append(pop + " ");
                        }
                    }
                    stack.push(group);
                }
            } else {//是数字
                sufExpr.append(group + " ");
            }
        }
        String pop = null;
        while (null != (pop = stack.pop())) {
            sufExpr.append(pop + " ");
        }
        return sufExpr.toString();
    }

    /**
     * 设置出栈优先级，(：优先级最低，表示只有遇到)才能出栈
     * 当栈顶遇到优先级比自己小或等于的弹栈
     */
    public  Integer getPriority(String c) {
        if (c == null) {
            return 0;
        }
        switch (c) {
            case "(":
                return 1;
            case "+":
            case "-":
                return 2;
            case "*":
            case "/":
            case "%":
                return 3;
            case ">":
            case "<":
            case ">=":
            case "<=":
            case "!=":
            case "==":
                return 4;
            case "|":
                return 5;
            case "=":
                return 6;
            case "(int)":
                return 7;
        }
        return 0;
    }

    /**
     * 计算值
     */
    public  BigDecimal cal(BigDecimal a1, BigDecimal a2, String operator) throws Exception {
        switch (operator){
            case "+":return a1.add(a2);
            case "-":return a1.subtract(a2);
            case "*":return a1.multiply(a2);
            case "/":return a1.divide(a2,3,BigDecimal.ROUND_CEILING);
            case "%":return a1.divideAndRemainder(a2)[1];
            default:
                break;
        }
        throw new Exception("非法运算符");
    }

    public  Boolean calBoolean(BigDecimal a1, BigDecimal a2, String operator) throws Exception {
        switch (operator){
            case ">":return a1.compareTo(a2) == 1;
            case "<":return a1.compareTo(a2) == -1;
            case ">=":return a1.compareTo(a2) > -1;
            case "<=":return a1.compareTo(a2) < 1;
            case "!=":return a1.compareTo(a2) != 0;
            case "==":return a1.compareTo(a2) == 0;
            default:
                break;
        }
        throw new Exception("非法运算符");
    }

    /**
     * 计算后缀表达式
     */
    public  BigDecimal calSufExpr(String sufExpr) throws Exception {
        Stack<BigDecimal> stack = new Stack<>();
        Pattern pattern=Pattern.compile("\\(int\\)|-?\\d+(\\.\\d+)?|!=|>=|<=|==|[+\\-*/%><=]");//提取运算符和数字
        Matcher matcher = pattern.matcher(sufExpr);
        BigDecimal result=new BigDecimal("0.0");
        while (matcher.find()){
            String group = matcher.group();
            if(group.matches("[+\\-*/%]")){
                BigDecimal a1 =stack.pop();
                BigDecimal a2 =stack.pop();
                result = cal(a2, a1, group);
                stack.push(result);
            }
            else if(group.equals("(int)")){
                BigDecimal pop = stack.pop();
                BigDecimal bigDecimal = pop.setScale(0, BigDecimal.ROUND_DOWN);
                stack.push(bigDecimal);
            }
            else if(group.matches("!=|>=|<=|==|[><]")){
                BigDecimal a1 =stack.pop();
                BigDecimal a2 =stack.pop();
                stack.push(calBoolean(a2,a1,group)?new BigDecimal(1):new BigDecimal(0));
            }
            else if(group.equals("=")){
                BigDecimal a1 =stack.pop();
                BigDecimal a2 =stack.pop();
                if (a2.compareTo(new BigDecimal(1))==0) {
                    stack.push(a1);
                }
            }
            else {//为数字直接压栈
                stack.push(new BigDecimal(group));
            }
        }
        return result;
    }


    /**
     * 新增内转汽运详单
     * @param orderId
     * @return
     * @throws Exception
     */
    @Override
    public int addConvertedDetailsOrder(BigDecimal orderId) throws Exception {
        // 得到最大id
        BigDecimal detailsId = selectMaxId();
        String detailsNo = noUtil.setResultNo("QYXD", detailsId);
        // 新增详单实体
        BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
        // 设置常规字段
        bmstruckDetailsOrder.setInsertTime(new Date());
        bmstruckDetailsOrder.setInsertUsername("admin");
        bmstruckDetailsOrder.setInsertUpdateRemark("无");
        // 通过订单号获取物资信息以及结算方式
        Map<String, Object> mapVal=getSettlement(orderId);
        //需求类型（0：计重；1：计时；2：计次；3：包月）
        String requirementType=mapVal.get("requirementType").toString();
        Integer materialId =Integer.parseInt(mapVal.get("materialId").toString());
        //通过物资id以及结算方式获取单价；
        BigDecimal priceId=getPriceByWz(requirementType,materialId);
        // 将单价存入实体
        bmstruckDetailsOrder.setPriceId(priceId);
        // 获取物资数量/计时获取时长/计数为一次/包月为包月价
        if("0".equals(requirementType)){
            //通过单价ID获取单价
            BigDecimal price=getPriceValue(priceId);
            //获取物资重量
            BigDecimal weight=getNetWeight(priceId);
            bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(price.doubleValue()*weight.doubleValue()));
        }
        else{
            //通过单价ID获取单价
            BigDecimal price=getPriceValue(priceId);
            bmstruckDetailsOrder.setDetailsAmount(price);
        }
        return bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
    }
    //通过物资id以及结算方式获取单价；
    @Override
    public BigDecimal getPriceByWz(String requirementType, Integer materialId) {
        return bmstruckDetailsOrderMapper.getPriceByWz(requirementType,materialId);
    }

    @Override
    // 通过订单号获取物资信息以及结算方式
    public Map<String, Object> getSettlement(BigDecimal orderId) {
        return bmstruckDetailsOrderMapper.getSettlement(orderId);
    }

    /**
     * 修改详单
     * @param mapValue
     * @return
     */
    @Transactional
    @Override
    public int updateDetailsOrder(Map<String, Object> mapValue) {
        BigDecimal priceId = DataChange.dataToBigDecimal(mapValue.get("priceId"));
        BigDecimal detailsId = DataChange.dataToBigDecimal(mapValue.get("detailsId"));
        BmstruckDetailsOrder bmstruckDetailsOrder = bmstruckDetailsOrderMapper.selectByPrimaryKey(detailsId);
        // 重新设置单价
        BigDecimal priceId1 = bmstruckDetailsOrder.getPriceId();
        bmstruckDetailsOrder.setPriceids(priceId1+","+priceId);
        bmstruckDetailsOrder.setPriceId(priceId);
        BigDecimal weightTaskResultId = bmstruckDetailsOrder.getWeightTaskResultId();
        BigDecimal orderId = bmstruckDetailsOrderMapper.getOrderId(weightTaskResultId);
        OmstruckOrder omstruckOrder = new OmstruckOrder();
        omstruckOrder.setOrderId(orderId);
        omstruckOrder.setPriceId(priceId);
        omstruckOrderMapper.updateByPrimaryKeySelective(omstruckOrder);
        try {
            // 计算出新的详单金额
            BigDecimal newAmount = generateTruckFees(orderId,weightTaskResultId);
            bmstruckDetailsOrder.setDetailsAmount(newAmount);
        } catch (Exception e) {
            e.printStackTrace();
        }
        try{
            //修改计量表的历史时间
            omstruckOrderMapper.modifyOldTime(priceId,new Date());
        }catch (Exception e){
            System.out.println("更新历史时间失败");
        }
        int result = bmstruckDetailsOrderMapper.updateByPrimaryKeySelective(bmstruckDetailsOrder);
        return result;
    }

    @Override
    public BigDecimal getCarrierIdBySSO(String carrierSsoId) {
        return bmstruckDetailsOrderMapper.getCarrierIdBySSO(carrierSsoId);
    }

    // 根据单价id查询价格和地址
    @Override
    public Map<String,Object> findAddressAndPrice(Integer priceId) {
        return bmstruckDetailsOrderMapper.findAddressAndPrice(new BigDecimal(priceId));
    }

    /**
     * 增加焦炭途损费
     * @param map
     * @return
     */
    @Override
    public int addLossFeeOfCoke(Map<String,Object> map) {
        BigDecimal lossFees = DataChange.dataToBigDecimal(map.get("lossFees"));
        BigDecimal detailsId = DataChange.dataToBigDecimal(map.get("detailsId"));
        BmstruckDetailsOrder bmstruckDetailsOrder = bmstruckDetailsOrderMapper.selectByPrimaryKey(detailsId);
        BigDecimal detailsAmount = bmstruckDetailsOrder.getDetailsAmount();
        DecimalFormat df = new DecimalFormat("0.00");
        Double newAmount = detailsAmount.doubleValue() - lossFees.doubleValue();
        String newAmountStr = df.format(newAmount);
        bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(newAmountStr));
        int result = bmstruckDetailsOrderMapper.updateByPrimaryKeySelective(bmstruckDetailsOrder);
        return result;
    }

    /*
    内转计重计费详单
     */
    @Override
    public List<Map<String, Object>> getInwardWeightDetailsOrder(Map<String, Object> mapValue, Integer orderType) {
        List<Map<String,Object>>mapList = new ArrayList<>();
        switch (orderType){
            case 10:
                List<Map<String, Object>> inwardReportResult =  bmstruckDetailsOrderMapper.getPurInwarWeightDetailsOrder(mapValue);
                return inwardReportResult;
            case 21:
                return bmstruckDetailsOrderMapper.getInwardTimeDetailsOrder(mapValue);
            case 11:
                return bmstruckDetailsOrderMapper.getAllInwardWeight(mapValue);
            case 26:
                return bmstruckDetailsOrderMapper.getInwardCountDetailsOrder(mapValue);
            default:
                break;
        }
        return mapList;
    }

    @Override
    public int inserInwardOrder(Map<String, Object> mapVal) {
        //获取运输订单ID
        BigDecimal orderId= DataChange.dataToBigDecimal(mapVal.get("orderId"));
        //根据运输订单去查找订单类型
        BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(orderId);
        //根据运输订单id去查询计费详单id
        if(bmstruckDetailsOrderMapper.selectDetailsByOrder(orderId) > 0){
            return -1;
        }
        List<Map<String,Object>> priceAmountList = new ArrayList<>();
        if(inwardTypeList.contains(orderType.intValue())){
            //获取该订单的计量实绩ID以及净重,只会返回一条数据
            priceAmountList = bmstruckDetailsOrderMapper.getWeightTaskResultId(orderId);
        }
        if(toLineAndMaterial.contains(orderType.intValue())){
            //如果在以上订单类型里面则需要根据运输订单ID去找线路和物资
            Map<String,Object> priceInfoPur = bmstruckDetailsOrderMapper.getPriceInfoPur(orderId);
            //根据物资品类ID和承运起止范围去匹配单价
            Map<String,Object> map = bmstruckDetailsOrderMapper.getPurInwardPrice(priceInfoPur);
            if(map != null){
                mapVal.putAll(map);
            }else{
                return -1;
            }
        }
        if(fixLineList.contains(orderType.intValue())){
            //拼装车皮进厂以及一焦化采购焦炭进厂
            Map<String,Object> priceInfoPur = bmstruckDetailsOrderMapper.getPriceInfoPur(orderId);
            priceInfoPur.put("transRangeId",1);
            //根据物资品类ID和承运起止范围去匹配单价
            Map<String,Object> map = bmstruckDetailsOrderMapper.getPurInwardPrice(priceInfoPur);
            if(map != null){
                mapVal.putAll(map);
            }else{
                return -1;
            }
        }
        if(steelTypeList.contains(orderType.intValue())){
            //钢材倒库
            //首先获取净重
            //BigDecimal netWeight = bmstruckDetailsOrderMapper.selectNetWeight(orderId);
            //mapVal.put("netWeight",netWeight);
            //获取单价
            Map<String, Object> priceInfoPur = new HashMap<>();
            priceInfoPur.put("transRangeId",1);
            priceInfoPur.put("materialTypeId",5102);
            Map<String,Object> map = bmstruckDetailsOrderMapper.getPurInwardPrice(priceInfoPur);
            if(map != null){
                mapVal.putAll(map);
            }else{
                return -1;
            }
        }
        if(orderType.intValue() == 21 || orderType.intValue()==26){
            //计时/计次
            priceAmountList.add(mapVal);
        }
        //获取单价ID
        BigDecimal priceId = DataChange.dataToBigDecimal(mapVal.get("priceId")) ;
        //获取单价值
        BigDecimal priceValue = DataChange.dataToBigDecimal(mapVal.get("priceValue"));
        if(priceId == null){
            System.out.println(orderId + "没有单价");
            return 1;
        }
        int result = 0;
        for (Map<String, Object> map : priceAmountList) {
            BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
            //查询计重且计时
            String s = bmstruckDetailsOrderMapper.selectWeightAndTimeByOrderId(orderId);
            int num=0;
            if (s!=null && s.contains("计时且过计量")){
                num=21;
            }
            if(inwardTypeList.contains(orderType.intValue()) && num==0){
                BigDecimal weightTaskResultId = DataChange.dataToBigDecimal(map.get("weightTaskResultId"));
                BigDecimal netWeight = null;
                if(mapVal.get("netWeight") != null) {
                     //因为事务的关系,部分订单结束时可能没有净重，故需要添加净重
                     netWeight = DataChange.dataToBigDecimal(mapVal.get("netWeight"));
                }
                else{
                     netWeight = DataChange.dataToBigDecimal(map.get("netWeight"));
                }
                //计算详单金额
                BigDecimal detailsAmount = new BigDecimal(priceValue.doubleValue()*netWeight.doubleValue());
                //保留两位小数
                DecimalFormat df = new DecimalFormat("0.00");
                String format = df.format(detailsAmount);
                //关联计量实绩
                bmstruckDetailsOrder.setWeightTaskResultId(weightTaskResultId);
                if(priceId != null && priceValue !=null && detailsAmount.intValue() > 0){
                    bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(format));
                }
            }
            //内转计时结算
            if(orderType.intValue() == 21 || num==21){
                BigDecimal resultTime = DataChange.dataToBigDecimal(mapVal.get("Time1"));
                //保留两位小数
                DecimalFormat df = new DecimalFormat("0.00");
                BigDecimal settleTime  = new BigDecimal(String.valueOf(resultTime.divide(new BigDecimal(60), 14, BigDecimal.ROUND_HALF_UP)));
                if(settleTime.doubleValue()<2.00){
                    BigDecimal detailsAmount = new BigDecimal(priceValue.doubleValue()*2);
                    bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(df.format(detailsAmount)));
                }else{
                    BigDecimal detailsAmount = new BigDecimal(priceValue.doubleValue()*settleTime.doubleValue());
                    bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(df.format(detailsAmount)));
                }
            }
            //内转计次结算
            if(orderType.intValue() == 26){
                //保留两位小数
                DecimalFormat df = new DecimalFormat("0.00");
                BigDecimal detailsAmount = new BigDecimal(priceValue.doubleValue());
                bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(df.format(detailsAmount)));
            }
            bmstruckDetailsOrder.setPriceId(priceId);
            bmstruckDetailsOrder.setInsertUpdateRemark("单价存在");
            // 得到最大id
            BigDecimal detailsId = selectMaxId();
            bmstruckDetailsOrder.setOrderId(orderId);
            String detailsNo = noUtil.setResultNo("QYXD", detailsId);
            bmstruckDetailsOrder.setDetailsId(detailsId);
            bmstruckDetailsOrder.setDetailsNo(detailsNo);
            bmstruckDetailsOrder.setDetailsTime(new Date());
            // 设置常规字段
            bmstruckDetailsOrder.setInsertTime(new Date());
            bmstruckDetailsOrder.setWetherToStatement(new BigDecimal(0));
            bmstruckDetailsOrder.setInsertUsername("admin");
            bmstruckDetailsOrder.setUpdateUsername("admin");
            result += bmstruckDetailsOrderMapper.insertSelective(bmstruckDetailsOrder);
        }
        return result;
    }

    @Override
    public int updateDetails() {
        List<Map<String,Object>>mapList = bmstruckDetailsOrderMapper.selectDetailsNoAmount();
        int i=0;
        for (Map<String,Object>map:mapList
             ) {
            //获取详单ID、价格值，净重
            BigDecimal detailsId = DataChange.dataToBigDecimal(map.get("detailsId"));
            BigDecimal netWeight = DataChange.dataToBigDecimal(map.get("netWeight"));
            BigDecimal priceValue = DataChange.dataToBigDecimal(map.get("priceValue"));
            BmstruckDetailsOrder bmstruckDetailsOrder = new BmstruckDetailsOrder();
            bmstruckDetailsOrder.setDetailsId(detailsId);
            BigDecimal detailsAmount = new BigDecimal(priceValue.doubleValue()*netWeight.doubleValue());
            DecimalFormat df = new DecimalFormat("0.00");
            String format = df.format(detailsAmount);
            bmstruckDetailsOrder.setDetailsAmount(new BigDecimal(format));
            i += bmstruckDetailsOrderMapper.updateByPrimaryKeySelective(bmstruckDetailsOrder);
        }
        return i;
    }
    /*
    内转计重+计时计费详单
     */
    @Override
    public List<Map<String, Object>> getInwardWeightTimeDetailsOrder(Map<String, Object> mapValue, Integer orderType) {

        List<Map<String,Object>>mapListWeight = new ArrayList<>();
        List<Map<String,Object>>mapListTime = new ArrayList<>();
               //计重计费详单查询结果
               mapListWeight = bmstruckDetailsOrderMapper.getInwardWeightDetailsOrder(mapValue);
               //for(Map<String, Object> mapListWeightOne : mapListWeight)
               //{
               //     mapListWeightOne.put("resultTime","null");
               //}
               //计时计费详单查询结果
               mapListTime = bmstruckDetailsOrderMapper.getInwardTimeDetailsOrder(mapValue);
               //将计时查询结果加入到计重查询结果中
               for(Map<String, Object> mapListTimeOne:mapListTime)
           {    mapListTimeOne.put("capacityNumber",mapListTimeOne.remove("capacityNum"));
               mapListWeight.add(mapListTimeOne);
           }
               //返回计重+计时计费详单查询结果
        return mapListWeight;
    }

    @Override
    public List<Map<String, Object>> getNoInwardDetails(Map<String, Object> mapValue) {
        return bmstruckDetailsOrderMapper.getNoInwardDetails(mapValue);
    }

    @Override
    public List<Map<String, Object>> getSteelTruckDetailsOrder(Map<String, Object> mapValue) {
        return bmstruckDetailsOrderMapper.getSteelTruckDetailsOrder(mapValue);
    }

    @Override
    public int newInwardSettle(List<Map<String,Object>> orderIds) {
        int count = 0;
        //遍历数组
        for(Map<String,Object> orderIdMap:orderIds){
            Integer orderId = DataChange.dataToBigDecimal(orderIdMap.get("orderId")).intValue();
            //根据运输ID获取订单类型
            BigDecimal orderType = bmstruckDetailsOrderMapper.getOrderType(new BigDecimal(orderId));
            //根据订单类型调用不同的方法
            //如果订单类型是11,
            if(orderType.intValue() == 11){
                List<BigDecimal> detailsIds = bmstruckDetailsOrderMapper.getDetailsIdByOrderId(orderId);
                if(detailsIds.size() == 0){
                    omsFeign.closeInwardOrder(orderId);
                    count++;
                }else{
                    for(int i=0;i<detailsIds.size();i++){
                        bmstruckDetailsOrderMapper.deleteByPrimaryKey(detailsIds.get(i));
                        omsFeign.closeInwardOrder(orderId);
                        count++;
                    }
                }
            }
            if(orderType.intValue() == 10 || orderType.intValue() == 20){
                //根据运输订单ID找寻计费详单ID
                List<BigDecimal> detailsIds = bmstruckDetailsOrderMapper.getDetailsIdByOrderId(orderId);
                for(BigDecimal detailsId:detailsIds){
                    //根据详单ID物理删除详单
                    bmstruckDetailsOrderMapper.deleteByPrimaryKey(detailsId);
                    count++;

                }
                inserInwardOrder(orderIdMap);
            }
            if(orderType.intValue() == 23 || orderType.intValue() == 24){
                List<BigDecimal> detailsIds = bmstruckDetailsOrderMapper.getDetailsIdByOrderId(orderId);
                for(BigDecimal detailsId:detailsIds){
                    //根据详单ID物理删除详单
                    bmstruckDetailsOrderMapper.deleteByPrimaryKey(detailsId);
                    count++;
                }
                inserInwardOrder(orderIdMap);
            }
            if(orderType.intValue() == 16 || orderType.intValue() == 15){
                List<BigDecimal> detailsIds = bmstruckDetailsOrderMapper.getDetailsIdByOrderId(orderId);
                for(BigDecimal detailsId:detailsIds){
                    //根据详单ID物理删除详单
                    bmstruckDetailsOrderMapper.deleteByPrimaryKey(detailsId);
                    count++;
                }
                inserInwardOrder(orderIdMap);
            }
        }
        return count;
    }


}