package com.xzx.gc.order.service;


import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.lang.Dict;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.xzx.gc.common.Result;
import com.xzx.gc.common.constant.Constants;
import com.xzx.gc.common.constant.OrderEnum;
import com.xzx.gc.common.utils.*;
import com.xzx.gc.entity.*;
import com.xzx.gc.model.order.ScanDto;
import com.xzx.gc.model.system.ConfigInfoReq;
import com.xzx.gc.model.system.ConfigInfoVo;
import com.xzx.gc.order.mapper.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import tk.mybatis.mapper.entity.Example;

import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;


/**
 * 打卡入库
 */

@Service
@Transactional
@Slf4j
public class OrderBatchInfoService {

    @Autowired
    private OrderBatchInfoMapper orderBatchInfoMapper;

    @Autowired
    private OrderMapper orderMapper;

    @Autowired
    private OrderService orderService;

    @Autowired
    private PackageGoodsInfoService packageGoodsInfoService;

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private OrderClockInMapper orderClockInMapper;

    @Autowired
    private OrderStorageInfoMapper orderStorageInfoMapper;

    @Autowired
    private OrderItemInfoMapper orderItemInfoMapper;

    @Autowired
    private OtherUserMapper otherUserMapper;

    @Autowired
    private OrderStorageDetailMapper orderStorageDetailMapper;

    @Autowired
    private JGUtil jgUtil;

    @Autowired
    private IdUtils idUtils;

    @Autowired
    private ConfigService configService;

    @Autowired
    private UserVehicleRelMapper userVehicleRelMapper;

    @Autowired
    private VehicleInfoMapper vehicleInfoMapper;

    @Autowired
    private BusinessUtil businessUtil;

    @Autowired
    private SysStorageService sysStorageService;

    @Autowired
    private SysEnvironmentalInfoService sysEnvironmentalInfoService;

    @Autowired
    private JGPushUtil jgPushUtil;

    /**
     * 极光推送入库相关信息
     *
     * @param scanDto
     */
    private void sendToAnroid(ScanDto scanDto) {
        //如果是主动发起的请求 或者 定时请求但是结果是成功的则需要推送一条数据
        if(OrderEnum.主动请求.getValue().equals(Convert.toStr(scanDto.getTimeFlag(),OrderEnum.定时请求.getValue()))||Constants.RESULT_SUCCESS==scanDto.getCode()){
            jgPushUtil.pushClock(scanDto);
        }
    }


    /**
     * 扫码打卡
     * @param orderBatchInfo
     * @return
     */
    public Result<ScanDto> add(OrderBatchInfo orderBatchInfo) {
        ScanDto scanDto = new ScanDto();
        scanDto.setTimeFlag(orderBatchInfo.getTimeFlag());
        scanDto.setUserId(orderBatchInfo.getUserId());
        Result result = new Result();

        //空车误差百分比
        BigDecimal between= BigDecimal.ZERO;
        ConfigInfoReq configInfoReq=new ConfigInfoReq();
        configInfoReq.setConfigTypeCode("BETWEEN_WEIGHT");
        List<ConfigInfoVo> configInfoVos = configService.configInfoQuery(configInfoReq);
        if(CollUtil.isNotEmpty(configInfoVos)){
            between=Convert.toBigDecimal(configInfoVos.get(0).getConfigValue());
        }

        BigDecimal minWeight = BigDecimal.ZERO;
        UserVehicleRel userVehicleRel=new UserVehicleRel();
        userVehicleRel.setUserId(orderBatchInfo.getUserId());
        userVehicleRel.setDelFlag(Convert.toShort(Constants.DEL_NOT_FLAG));
        List<UserVehicleRel> select1 = userVehicleRelMapper.select(userVehicleRel);
        Long vehicleId=null;
        if(CollUtil.isNotEmpty(select1)){
            vehicleId = select1.get(0).getVehicleId();
            VehicleInfo vehicleInfo=new VehicleInfo();
            vehicleInfo.setId(vehicleId);
            vehicleInfo.setDelFlag(Convert.toShort(Constants.DEL_NOT_FLAG));
            VehicleInfo vehicleInfo1 = vehicleInfoMapper.selectOne(vehicleInfo);
            minWeight=Convert.toBigDecimal(vehicleInfo1.getWeight());
            log.info("当前用户：{}，空车重量：{}",orderBatchInfo.getUserId(),minWeight);
        }else{
            scanDto.setReason("没有绑定车辆");
            scanDto.setCode(Constants.RESULT_ERROR);
            scanDto.setReasonDesc("没有与当前用户:{"+orderBatchInfo.getUserId()+"}绑定的车辆");
            sendToAnroid(scanDto);
            return Result.error(Constants.RESULT_ERROR, "没有与当前用户绑定的车辆");
        }
        //设置车辆
        orderBatchInfo.setVehicleId(vehicleId);

        //打卡时间
        String createTime = orderBatchInfo.getCreateTime();

        DateTime parse = DateUtil.parse(createTime, DateUtils.DATE_FORMAT_YMD);
        DateTime parse2= DateUtil.parse(DateUtil.now(),DateUtils.DATE_FORMAT_YMD);
        if(!DateUtil.isSameDay(parse,parse2)){
            log.warn("地磅时间不准确，请校准");
            scanDto.setReason("地磅时间不准确，请校准");
            scanDto.setCode(Constants.RESULT_ERROR);
            scanDto.setReasonDesc("地磅时间不对：错误时间为"+createTime);
            sendToAnroid(scanDto);
            return Result.error(Constants.RESULT_ERROR, "地磅时间不准确");
        }



        OrderClockIn today = orderClockInMapper.findToday(orderBatchInfo.getUserId(), StrUtil.split(createTime, " ")[0]);

        if (today == null) {
            boolean lock=false;
            //空车打卡
            try {
                List<OrderInfo> select= orderService.findDetailByReceiverAndStatus(orderBatchInfo.getUserId(),OrderEnum.待入库.getValue());
                //判断是否还存在待入库的订单
                if (CollUtil.isNotEmpty(select)) {
                    //入库打卡 打卡时间更改为最近订单完成时间的当天空车打卡时间
                    String completeTime = select.get(0).getCompleteTime();

                    //当天可能属于不用打卡的配置里 取不到打卡重量则取车重为打卡重量
                    today = orderClockInMapper.findToday(orderBatchInfo.getUserId(), StrUtil.split(completeTime, " ")[0]);
                    if(today==null){
                        today=new OrderClockIn();
                        today.setWeight(Convert.toStr(minWeight));
                    }
                    Result<ScanDto> rk = rk(today, scanDto, orderBatchInfo);
                    if(rk!=null){
                        return rk;
                    }
                }else {
                    scanDto.setDesc("空车打卡失败");
                    scanDto.setType(OrderEnum.空车.getValue());

                    //防重复打卡
                    if (redisUtil.setnx(Constants.REDIS_ORDER_KEY + "clock:" + orderBatchInfo.getUserId(), orderBatchInfo.getUserId())) {
                        lock = true;
                        OrderClockIn today1 = orderClockInMapper.findToday(orderBatchInfo.getUserId(), StrUtil.split(createTime, "")[0]);
                        if (today1 != null) {
                            scanDto.setReason("您今天已打过卡了");
                            scanDto.setCode(Constants.RESULT_ERROR);
                            sendToAnroid(scanDto);
                            return Result.error(Constants.RESULT_ERROR, "您今天已打过卡了");
                        }

                        String weight = orderBatchInfo.getWeight();
                        if (Convert.toBigDecimal(weight).compareTo(minWeight) < 0) {
                            scanDto.setReason("当前重量异常，请确保货车已在地秤上");
                            scanDto.setReasonDesc("空车当前重量为：" + weight + ",最小重量为:" + minWeight);
                            scanDto.setCode(Constants.RESULT_ERROR);
                            sendToAnroid(scanDto);
                            return Result.error(Constants.RESULT_ERROR, "当前重量异常，请确保货车已在地秤上：" + weight);
                        }

                        //空车最大范围
                        BigDecimal maxWeight = NumberUtil.add(minWeight, NumberUtil.mul(minWeight, between));
                        if (Convert.toBigDecimal(weight).compareTo(maxWeight) > 0) {
                            scanDto.setReason("当前重量异常，已超过最大重量");
                            scanDto.setReasonDesc("空车当前重量为：" + weight + ",最大重量为:" + maxWeight);
                            scanDto.setCode(Constants.RESULT_ERROR);
                            sendToAnroid(scanDto);
                            return Result.error(Constants.RESULT_ERROR, "当前重量异常，已超过最大重量：" + weight);
                        }


                        OrderClockIn orderClockIn = new OrderClockIn();
                        BeanUtils.copyProperties(orderBatchInfo, orderClockIn);
                        orderClockInMapper.insertSelective(orderClockIn);

                        scanDto.setCreateTime(DateUtil.parse(createTime).toString(DateUtils.DATE_FORMAT_YMDHM));
                        scanDto.setEmptyWeight(Convert.toBigDecimal(orderBatchInfo.getWeight()));
                        scanDto.setDesc("空车打卡成功");
                        sendToAnroid(scanDto);
                    }
                }
            } catch (Exception e) {
                scanDto.setReason("程序异常");
                scanDto.setCode(Constants.RESULT_ERROR);
                sendToAnroid(scanDto);
                ExceptionUtils.err(Constants.RESULT_ERROR, "空车打卡失败", e);
            } finally {
                if(lock) {
                    redisUtil.del(Constants.REDIS_ORDER_KEY + "clock:" + orderBatchInfo.getUserId());
                }
            }
        } else {
            /*********入库*****************/
            Result<ScanDto> rk = rk(today, scanDto, orderBatchInfo);
            if(rk!=null){
                return rk;
            }
        }
        result.setData(scanDto);
        return result;
    }


    /**
     * 载货打卡
     * @param today
     * @param scanDto
     * @param orderBatchInfo
     * @return
     */
    public Result<ScanDto> rk( OrderClockIn today,ScanDto scanDto,OrderBatchInfo orderBatchInfo){
        String orderIds = "";
        boolean lock=false;
        try {
            BigDecimal bigDecimal = Convert.toBigDecimal(today.getWeight());
            if (Convert.toBigDecimal(orderBatchInfo.getWeight()).compareTo(bigDecimal) <= 0) {
                scanDto.setReason("当前重量异常，请确保货车已在地秤上");
                scanDto.setReasonDesc("空车当前重量为：" + today.getWeight() + ",载货重量为:" + orderBatchInfo.getWeight());
                scanDto.setCode(Constants.RESULT_ERROR);
                sendToAnroid(scanDto);
                return Result.error(Constants.RESULT_ERROR, "重量异常，请确保货车已在地秤上：" + orderBatchInfo.getWeight());
            }


            scanDto.setDesc("载货打卡失败");
            scanDto.setType(OrderEnum.载货.getValue());

            String userId = orderBatchInfo.getUserId();

            String timeOrder="";
            //获取用户所有待入库订单
            List<OrderInfo> select= orderService.findDetailByReceiverAndStatus(orderBatchInfo.getUserId(),OrderEnum.待入库.getValue());
            if (CollUtil.isEmpty(select)) {
                scanDto.setReason("没有待入库的订单");
                scanDto.setCode(Constants.RESULT_ERROR);
                sendToAnroid(scanDto);
                return Result.error(Constants.RESULT_ERROR, "没有待入库的订单");
            }else {
                //筛选比打卡时间晚的订单  地磅自动修复的BUG
                for (Iterator<OrderInfo> iterator = select.iterator(); iterator.hasNext(); ) {
                    OrderInfo orderInfo =  iterator.next();
                    String completeTime = orderInfo.getCompleteTime();
                    DateTime parse3 = DateUtil.parse(orderBatchInfo.getCreateTime(), DateUtils.DATE_FORMAT_YMDHMS);
                    DateTime parse4= DateUtil.parse(completeTime,DateUtils.DATE_FORMAT_YMDHMS);
                    //订单完成时间比打卡时间晚 则过滤掉
                    if(DateUtil.compare(parse4,parse3)>=0){
                        timeOrder=orderInfo.getOrderId()+",";
                        iterator.remove();
                    }
                }
            }

            if (CollUtil.isEmpty(select)) {
                scanDto.setReason("没有待入库的订单");
                scanDto.setCode(Constants.RESULT_ERROR);
                scanDto.setReasonDesc("没有待入库的订单,存在订单:【"+timeOrder+"】已超出打卡时间"+orderBatchInfo.getCreateTime()+"的情况");
                sendToAnroid(scanDto);
                return Result.error(Constants.RESULT_ERROR, "没有待入库的订单");
            }

            List<String> collect = select.stream().map(OrderInfo::getOrderId).collect(Collectors.toList());
            String join = CollUtil.join(collect, ",");
            orderIds = join;
            //防止重复扫码
            if (redisUtil.setnx(Constants.REDIS_ORDER_KEY + "batch:" + join, join)) {
                lock=true;
                //二次验证
                Example example1 = new Example(OrderBatchInfo.class);
                example1.createCriteria().andEqualTo("orderId", join);
                OrderBatchInfo orderBatchInfo1 = orderBatchInfoMapper.selectOneByExample(example1);
                if (orderBatchInfo1 != null) {
                    scanDto.setReason("当前订单已被扫码");
                    scanDto.setReasonDesc("订单号：" + join);
                    scanDto.setCode(Constants.RESULT_ERROR);
                    sendToAnroid(scanDto);
                    return Result.error(Constants.RESULT_ERROR, "当前订单已被扫码");
                }

                orderBatchInfo.setStatus(Convert.toShort(1));
                orderBatchInfo.setOrderId(join);
                orderBatchInfoMapper.insertSelective(orderBatchInfo);
                //入库相关数据库操作

                List<String> collect1 = select.stream().filter(x -> x.getStoreId() != null).map(OrderInfo::getOrderId).collect(Collectors.toList());

                List<String> collect2 = select.stream().filter(x -> x.getStoreId() == null).map(OrderInfo::getOrderId).collect(Collectors.toList());

                //门店下单的数据

                BigDecimal weight=BigDecimal.ZERO;
                if(CollUtil.isNotEmpty(collect1)){
                    String storageId = idUtils.generate("RK", 0);
                    Dict dict = addDB(userId, collect1,storageId,1,null);
                    if (dict.get("recycleWeight") != null) {
                        weight=NumberUtil.add(weight,Convert.toBigDecimal(dict.getStr("recycleWeight")));
                    }
                }

                //正常下单的数据
                if(CollUtil.isNotEmpty(collect2)){
                    String storageId = idUtils.generate("RK", 2);
                    Dict dict = addDB(userId, collect2,storageId,1,null);
                    if (dict.get("recycleWeight") != null) {
                        weight=NumberUtil.add(weight,Convert.toBigDecimal(dict.getStr("recycleWeight")));
                    }
                }

                scanDto.setOrderWeight(Convert.toBigDecimal(businessUtil.changeWeight(Convert.toStr(weight))));
                scanDto.setCreateTime(DateUtil.parse(orderBatchInfo.getCreateTime()).toString(DateUtils.DATE_FORMAT_YMDHM));

                scanDto.setWeight(Convert.toBigDecimal(orderBatchInfo.getWeight()));
                scanDto.setDesc("载货打卡成功");
                scanDto.setEmptyWeight(Convert.toBigDecimal(today.getWeight()));
                sendToAnroid(scanDto);
            }

        } catch (Exception e) {
            redisUtil.hincrBy(Constants.REDIS_ORDER_KEY+"storage:errcount",orderBatchInfo.getUserId(),1);
            scanDto.setReason("程序异常");
            scanDto.setCode(Constants.RESULT_ERROR);
            sendToAnroid(scanDto);
            ExceptionUtils.err(Constants.RESULT_ERROR, "载货打卡失败", e);
        } finally {
            if(lock) {
                redisUtil.del(Constants.REDIS_ORDER_KEY + "batch:" + orderIds);
            }
        }
        return null;
    }


    /**
     * 入库信息操作
     * @param userId
     * @param collect
     * @return
     */
    public Dict addDB(String userId, List<String> collect,String storageId,int usertype,String packageId) {
        Dict res = Dict.create();
        /*******入库新增*******/
        String join = CollUtil.join(collect, ",");
        OrderStorageInfo orderStorageInfo = new OrderStorageInfo();
        orderStorageInfo.setStorageId(storageId);
        orderStorageInfo.setOrderId(join);
        orderStorageInfo.setStorageStatus(Convert.toShort(OrderEnum.入库检验中.getValue()));
        //回收价格
        BigDecimal recycleMmoney = BigDecimal.ZERO;
        BigDecimal recycleWeight = BigDecimal.ZERO;
        Map<String, Dict> map = new HashMap<>();
        for (String orderId : collect) {
            OrderItemInfo orderItemInfo = new OrderItemInfo();
            orderItemInfo.setOrderId(orderId);
            List<OrderItemInfo> select1 = orderItemInfoMapper.select(orderItemInfo);
            if (CollUtil.isNotEmpty(select1)) {
                for (OrderItemInfo itemInfo : select1) {
                    if (StringUtils.isNotBlank(itemInfo.getMoney()) && Convert.toBigDecimal(itemInfo.getMoney()).compareTo(BigDecimal.ZERO)!=0) {
                        recycleMmoney = NumberUtil.add(recycleMmoney, new BigDecimal(itemInfo.getMoney()));
                    }
                    if (StringUtils.isNotBlank(itemInfo.getWeight()) &&Convert.toBigDecimal(itemInfo.getWeight()).compareTo(BigDecimal.ZERO)!=0) {
                        recycleWeight = NumberUtil.add(recycleWeight, new BigDecimal(itemInfo.getWeight()));
                    }

                    String itemType = itemInfo.getItemType();
                    String weight = StrUtil.isBlank(itemInfo.getWeight())?Constants.WEIGHT_INIT.toString():itemInfo.getWeight();
                    String amount = StrUtil.isBlank(itemInfo.getAmount())?"0":itemInfo.getAmount();
                    String money = StrUtil.isBlank(itemInfo.getMoney())?Constants.MONEY_INIT.toString():itemInfo.getMoney();
                    String price=StrUtil.isBlank(itemInfo.getPrice())?Constants.MONEY_INIT.toString():itemInfo.getPrice();
                    String rkPrice=StrUtil.isBlank(itemInfo.getPrice())?Constants.MONEY_INIT.toString():itemInfo.getPrice();
                    if(usertype==1&&StrUtil.isNotBlank(packageId)) {
                        //入库员要根据仓库id查找对应的入库价格
                        String area = sysStorageService.findById(Convert.toInt(packageId)).getArea();
                        BigDecimal putStoragePrice = sysEnvironmentalInfoService.findByItemTypeAndArea(itemType, Convert.toInt(area)).getPutStoragePrice();
                        rkPrice=businessUtil.changeMoney(putStoragePrice);
                    }


                    if (map.containsKey(itemType)) {
                        Dict dict = map.get(itemType);
                        if (dict.getBigDecimal("weight") != null) {
                            dict.set("weight", NumberUtil.add(dict.getBigDecimal("weight"), new BigDecimal(weight)));
                        }
                        if (dict.getBigDecimal("amount") != null) {
                            dict.set("amount", NumberUtil.add(dict.getBigDecimal("amount"), new BigDecimal(amount)));
                        }
                        if (dict.getBigDecimal("money") != null) {
                            dict.set("money", NumberUtil.add(dict.getBigDecimal("money"), new BigDecimal(money)));
                        }

                    } else {
                        Dict dict = Dict.create().set("weight", weight).set("amount", amount).set("money", money).set("price",price).set("rkPrice",rkPrice);
                        map.put(itemType, dict);
                    }
                }
            }
            //更改订单状态
            OrderInfo orderInfo1 = new OrderInfo();
            orderInfo1.setOrderId(orderId);
            //更新订单状态
            orderInfo1.setOrderStatus(OrderEnum.入库中.getValue());
            orderMapper.updateByPrimaryKeySelective(orderInfo1);
        }
        orderStorageInfo.setRecycleMoney(recycleMmoney);
        orderStorageInfo.setRecycleWeight(Convert.toStr(recycleWeight));
        res.set("recycleWeight", orderStorageInfo.getRecycleWeight());
        res.set("recycleMoney", Convert.toStr(orderStorageInfo.getRecycleMoney()));
        orderStorageInfo.setReceiver(userId);
        OtherUserInfo otherUserInfo = otherUserMapper.selectByPrimaryKey(userId);
        if (otherUserInfo != null) {
            orderStorageInfo.setReceiverName(otherUserInfo.getName());
            orderStorageInfo.setReceiverPhone(otherUserInfo.getMobilePhone());
            orderStorageInfo.setReceiverAvatar(otherUserInfo.getAvatar());
        }
        //添加入库记录

        if(usertype==1){
            orderStorageInfo.setSysStorageType(Convert.toShort(OrderEnum.仓库.getValue()));
        }else if(usertype==2){
            orderStorageInfo.setSysStorageType(Convert.toShort(OrderEnum.打包站.getValue()));
        }
        if(packageId!=null) {
            orderStorageInfo.setSysStorageId(Convert.toLong(packageId));
        }
        orderStorageInfoMapper.insertSelective(orderStorageInfo);
        res.set("storageId", storageId);

        /*************添加入库明细********************/
        List<OrderStorageDetailInfo> list = new ArrayList<>();

        if(usertype==1) {
            for (String s : map.keySet()) {
                OrderStorageDetailInfo orderStorageDetailInfo = new OrderStorageDetailInfo();
                orderStorageDetailInfo.setStorageId(storageId);
                //回收
                orderStorageDetailInfo.setFlag(OrderEnum.回收型.getValue());
                orderStorageDetailInfo.setItemType(s);
                orderStorageDetailInfo.setMoney(map.get(s).getStr("money"));
                orderStorageDetailInfo.setWeight(new BigDecimal(map.get(s).getStr("weight")));
                orderStorageDetailInfo.setAmount(map.get(s).getStr("amount"));
                orderStorageDetailInfo.setPrice(map.get(s).getStr("price"));

                orderStorageDetailMapper.insertSelective(orderStorageDetailInfo);
                list.add(orderStorageDetailInfo);

                OrderStorageDetailInfo orderStorageDetailInfo2 = new OrderStorageDetailInfo();
                BeanUtils.copyProperties(orderStorageDetailInfo, orderStorageDetailInfo2);
                orderStorageDetailInfo2.setPrice(map.get(s).getStr("rkPrice"));
                orderStorageDetailInfo2.setFlag(OrderEnum.入库型.getValue());
                orderStorageDetailMapper.insertSelective(orderStorageDetailInfo2);
            }
        }else if(usertype==2){
            List<PackageGoodsInfo> byPackageId = packageGoodsInfoService.findByPackageId(packageId);
            if(CollUtil.isNotEmpty(byPackageId)){
                for (PackageGoodsInfo packageGoodsInfo : byPackageId) {
                    OrderStorageDetailInfo orderStorageDetailInfo = new OrderStorageDetailInfo();
                    orderStorageDetailInfo.setStorageId(storageId);
                    //回收
                    orderStorageDetailInfo.setFlag(OrderEnum.回收型.getValue());
                    orderStorageDetailInfo.setItemType(packageGoodsInfo.getItemType());
                    orderStorageDetailInfo.setMoney(Constants.MONEY_INIT.toString());
                    orderStorageDetailInfo.setWeight(Constants.WEIGHT_INIT);
                    orderStorageDetailInfo.setAmount("0");

                    orderStorageDetailMapper.insertSelective(orderStorageDetailInfo);
                    list.add(orderStorageDetailInfo);

                    OrderStorageDetailInfo orderStorageDetailInfo2 = new OrderStorageDetailInfo();
                    BeanUtils.copyProperties(orderStorageDetailInfo, orderStorageDetailInfo2);
                    orderStorageDetailInfo2.setFlag(OrderEnum.入库型.getValue());
                    orderStorageDetailMapper.insertSelective(orderStorageDetailInfo2);
                }
            }
        }
        res.set("detail", list);
        return res;
    }







    public Map<String,Object> queryBatchInfoDetailList(String weightError, String  startTime,String  endTime,String userId,String vehicleId,String page, String limit){
        PageHelper.startPage(Convert.toInt(page),Convert.toInt(limit));
        List<Map<String,Object>> data = orderBatchInfoMapper.queryBatchInfoDetailList(weightError, startTime,endTime,userId,vehicleId);
        PageInfo<Map<String,Object>> pageInfo=new PageInfo<>(data);
        List<Map<String,String>> dataTimeWeightList = new ArrayList<>();
        for (Map<String,Object> obj:data) {
            //同一天的空车重量相同，对应打卡空车重量也相同。
            String orderId = obj.get("orderId").toString();
            if(orderId.equals("0")){
                Map<String,String> map = new HashMap<>();
                String time = obj.get("createtime").toString();
                String[] dayStr = time.split(" ");
                String cweight = obj.get("cweight").toString();
                map.put("day",dayStr[0]);
                map.put("clockWeight",cweight);
                dataTimeWeightList.add(map);
                obj.put("clockWeight","-");
            }
                obj.put("orderid",orderId);

        }
        //赋值给载重车的空车重量
        for (Map<String,Object> obj:data) {
            String orderId = obj.get("orderId").toString();
            BigDecimal we = new BigDecimal("0");
            if(!"0".equals(orderId)){
                String time = obj.get("createtime").toString();
                String timeStr = time.split(" ")[0];
                Map<String,Object> clockObj =orderBatchInfoMapper.queryEmptyWeight(weightError, timeStr+" 00:00:00",timeStr+" 23:59:59",userId,vehicleId);
                if(null!=clockObj){
                    obj.put("clockWeight",clockObj.get("cweight").toString());
                    we = new BigDecimal(obj.get("cweight").toString()).subtract(new BigDecimal(clockObj.get("cweight").toString()));
                }
            }else{
                we = new BigDecimal(obj.get("cweight").toString()).subtract(new BigDecimal(obj.get("vweight").toString()));

            }
            obj.put("weightError",we.toString());
        }

        Map<String, Object> map = new HashMap<>();
        map.put("data", data);
        map.put("count", pageInfo.getTotal());
        map.put("code", 0);
        return map;
    }

    public Map<String,Object> queryClockDetailList(String weightError, String  startTime,String  endTime,String userId,String vehicleId,String page, String limit){
        PageHelper.startPage(Convert.toInt(page),Convert.toInt(limit));
        List<Map<String,Object>> data = orderBatchInfoMapper.queryClockDetailList(weightError, startTime,endTime,userId,vehicleId);
        PageInfo<Map<String,Object>> pageInfo=new PageInfo<>(data);
        for (Map<String,Object> obj:data) {
            obj.put("clockWeight","-");
            BigDecimal we = new BigDecimal("0");
            we = new BigDecimal(obj.get("cweight").toString()).subtract(new BigDecimal(obj.get("vweight").toString()));
            obj.put("weightError",we.toString());
            obj.put("orderid",obj.get("orderId").toString());
        }
        Map<String, Object> map = new HashMap<>();
        map.put("data", data);
        map.put("count",pageInfo.getTotal());
        map.put("code", 0);
        return map;
    }

    public Map<String,Object> queryBatchDetailList(String weightError, String  startTime,String  endTime,String userId,String vehicleId,String page, String limit){
        PageHelper.startPage(Convert.toInt(page),Convert.toInt(limit));
        List<Map<String,Object>> data = orderBatchInfoMapper.queryBatchDetailList(weightError, startTime,endTime,userId,vehicleId);
        PageInfo<Map<String,Object>> pageInfo=new PageInfo<>(data);
        for (Map<String,Object> obj:data) {
            //计算当天打卡空车重量
            String time = obj.get("createtime").toString();
            if(null!=obj.get("orderId")){
                obj.put("orderid",obj.get("orderId").toString());
            }

            String timeStr = time.split(" ")[0];
            Map<String,Object> clockObj =orderBatchInfoMapper.queryEmptyWeight(weightError, timeStr+" 00:00:00",timeStr+" 23:59:59",userId,vehicleId);
            if(null!=clockObj){
                obj.put("clockWeight",clockObj.get("cweight").toString());

                BigDecimal we = new BigDecimal("0");
                we = new BigDecimal(obj.get("bweight").toString()).subtract(new BigDecimal(clockObj.get("cweight").toString()));
                obj.put("weightError",we.toString());
            }


        }
        Map<String, Object> map = new HashMap<>();
        map.put("data", data);
        map.put("count", pageInfo.getTotal());
        map.put("code", 0);
        return map;
    }
    
}