package com.glxp.api.service.collect;


import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.constant.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.dao.auth.InvWarehouseDao;
import com.glxp.api.dao.basic.BasicProductsDao;
import com.glxp.api.dao.basic.SysWorkplaceBusMapper;
import com.glxp.api.dao.collect.IoCollectCodeBackMapper;
import com.glxp.api.dao.collect.IoCollectCodeMapper;
import com.glxp.api.dao.collect.IoCollectOrderBackupMapper;
import com.glxp.api.dao.inout.IoCodeTempDao;
import com.glxp.api.entity.auth.AuthAdmin;
import com.glxp.api.entity.auth.InvWarehouseEntity;
import com.glxp.api.entity.auth.SysWorkplace;
import com.glxp.api.entity.basic.*;
import com.glxp.api.entity.collect.*;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.exception.JsonException;
import com.glxp.api.http.ErpBasicClient;
import com.glxp.api.http.sync.SpGetHttpClient;
import com.glxp.api.req.collect.CollectOrderBizRequest;
import com.glxp.api.req.collect.CollectOrderRequest;
import com.glxp.api.req.collect.CollectOrderUploadCountRequest;
import com.glxp.api.req.collect.PostCollectOrderRequest;
import com.glxp.api.req.inout.ReviewFinishRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.res.collect.CollectOrderBizResponse;
import com.glxp.api.res.collect.CollectOrderUploadCountResponse;
import com.glxp.api.res.collect.IoCollectOrderResponse;
import com.glxp.api.service.auth.InvWarehouseService;
import com.glxp.api.service.auth.SysWorkplaceService;
import com.glxp.api.service.basic.*;
import com.glxp.api.service.inout.IoAddInoutService;
import com.glxp.api.service.inout.IoCheckInoutService;
import com.glxp.api.service.inout.IoOrderService;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.util.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@Service
public class IoCollectOrderBackupService extends ServiceImpl<IoCollectOrderBackupMapper, IoCollectOrderBackup> {

    @Resource
    IoCollectOrderBackupMapper ioCollectOrderBackupMapper;
    @Resource
    IoCollectOrderBizBackupService ioCollectOrderBizBackupService;

    @Resource
    IoCollectOrderCodeAutoService collectOrderCodeAutoService;

    @Resource
    IoCollectOrderCodeManService collectOrderCodeManService;

    @Resource
    SysWorkplaceDocumentService sysWorkplaceDocumentService;

    @Resource
    IBasicBussinessTypeService bussinessTypeService;
    @Resource
    private GennerOrderUtils gennerOrderUtils;
    @Resource
    IoOrderService orderService;
    @Resource
    private IoCodeTempDao codesTempDao;

    @Resource
    IoAddInoutService addInoutService;

    @Resource
    @Lazy
    IoCheckInoutService ioCheckInoutService;

    @Resource
    private ErpBasicClient erpBasicClient;

    @Resource
    SpGetHttpClient spGetHttp;

    @Resource
    private RedisUtil redisUtil;

    @Resource
    IoCollectCodeBackService ioCollectCodeBackService;

    @Value("${WEB_TITLE}")
    private String WEB_TITLE;
    @Resource
    private SystemParamConfigService systemParamConfigService;
    @Resource
    private RelCodeDetailService relCodeDetailService;

    @Resource
    UdiRelevanceService udiRelevanceService;

    public List<IoCollectOrderResponse> filterList(CollectOrderRequest collectOrderRequest) {
        if (collectOrderRequest == null) {
            return Collections.emptyList();
        }
        if (collectOrderRequest.getPage() != null) {
            int offset = (collectOrderRequest.getPage() - 1) * collectOrderRequest.getLimit();
            PageHelper.offsetPage(offset, collectOrderRequest.getLimit());
        }
        List<IoCollectOrderResponse> data = ioCollectOrderBackupMapper.filterList(collectOrderRequest);
        return data;
    }

    public IoCollectOrderBackup getByBillNo(String billNo) {
        return ioCollectOrderBackupMapper.selectOne(new LambdaQueryWrapper<IoCollectOrderBackup>().eq(IoCollectOrderBackup::getBillNo, billNo).last("limit 1"));
    }
    public IoCollectOrderBackup getByBillNoNew(String billNo) {
        return ioCollectOrderBackupMapper.selectOne(new LambdaQueryWrapper<IoCollectOrderBackup>().eq(IoCollectOrderBackup::getBackupOrderRemark1, billNo).last("limit 1"));
    }
    public int updateByBillNo(IoCollectOrderBackup collectOrder) {
        return ioCollectOrderBackupMapper.update(collectOrder, new UpdateWrapper<IoCollectOrderBackup>().eq("billNo", collectOrder.getBillNo()));
    }
    @Resource
    private IoCollectCodeBackMapper ioCollectCodeBackMapper;
    public List<CollectOrderBizResponse> combieOrderDetail(CollectOrderBizRequest collectOrderBizRequest) {
        List<CollectOrderBizResponse> list = ioCollectOrderBizBackupService.filterList(collectOrderBizRequest);

        List<IoCollectOrderCodeAuto> splitCodes = collectOrderCodeAutoService.listByBillNo(collectOrderBizRequest.getOrderIdFk(), null);
//        List<IoCollectOrderCodeAuto> unSplitCodes = collectOrderCodeAutoService.listByBillNo(collectOrderBizRequest.getOrderIdFk(), 2);
        List<IoCollectOrderCodeMan> manList = collectOrderCodeManService.listByBillNo(collectOrderBizRequest.getOrderIdFk());

        List<CollectOrderBizResponse> collectOrderBizResponses = new ArrayList<>();
        for (CollectOrderBizResponse collectOrderBiz : list) {
            CollectOrderBizResponse collectOrderBizResponse = new CollectOrderBizResponse();
            BeanUtils.copyProperties(collectOrderBiz, collectOrderBizResponse);
            //查询自动赋码的code
            for (IoCollectOrderCodeAuto collectOrderCodeAuto : splitCodes) {
                if (IntUtil.value(collectOrderCodeAuto.getBizIdFk()) == IntUtil.value(collectOrderBiz.getId())) {
                    collectOrderBizResponse.setSplitUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getSplitUdiCode()) + "," + collectOrderCodeAuto.getUdiCode());
                }
            }
            //查询手动赋码的code
            for (IoCollectOrderCodeMan collectOrderCodeMan : manList) {
                if (IntUtil.value(collectOrderCodeMan.getBizIdFk()) == IntUtil.value(collectOrderBiz.getId())) {
                    collectOrderBizResponse.setScanUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getScanUdiCode()) + "," + collectOrderCodeMan.getUdiCode());
                }
            }
//            if (StrUtil.isNotEmpty(collectOrderBizResponse.getReplaceCode())) {
//                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getReplaceCode());
//            } else if (StrUtil.isNotEmpty(collectOrderBizResponse.getScanUdiCode())) {
//                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getScanUdiCode() == null ? "" : collectOrderBizResponse.getScanUdiCode().substring(1));
//            } else if (StrUtil.isNotEmpty(collectOrderBizResponse.getSplitUdiCode())) {
//                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getSplitUdiCode() == null ? "" : collectOrderBizResponse.getSplitUdiCode().substring(1));
//            }
            // 如果码没值就去备份表查询
            if(StringUtils.isEmpty(collectOrderBizResponse.getFinishUdiCode())){
                List<IoCollectCodeBackup> ioCollectCodeBackupList = ioCollectCodeBackMapper.selectList(new QueryWrapper<IoCollectCodeBackup>()
                        .eq("billNo",collectOrderBizRequest.getOrderIdFk())
                        .eq("relId",collectOrderBiz.getRelId())
                        .groupBy("code")
                );

                    if(CollUtil.isNotEmpty(ioCollectCodeBackupList)){
                    for (IoCollectCodeBackup ioCollectCodeBackup : ioCollectCodeBackupList) {
                        collectOrderBizResponse.setFinishUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getFinishUdiCode()) + "," + ioCollectCodeBackup.getCode());
                    }

                }
            }

            collectOrderBizResponses.add(collectOrderBizResponse);
        }
        return collectOrderBizResponses;
    }

    @Resource
    InvWarehouseService invWarehouseService;

    @Resource
    CompanyProductRelevanceService companyProductRelevanceService;

    @Transactional(rollbackFor = Exception.class)
    public void generateOrder(String billNo, AuthAdmin authAdmin) {
        IoCollectOrderBackup collectOrder = getByBillNo(billNo);

        SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByWorkplaceCode(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
        // 如果是null 就可能是上货工位进行医保上传
        if (Objects.isNull(sysWorkplaceDocumentEntity)) {
            sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.filterListExhibitGoods(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());

        }

        //1.内部系统，且单据为扫码生成业务单则创建系统单据
        if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() == 1) {
            //todo
            buildInnerOrder(collectOrder, sysWorkplaceDocumentEntity);
        } else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() != 1) {
            //更新单据为已完成
//            IoOrderEntity orderEntity = orderService.findByBillNo(collectOrder.getBillNo());
////            orderEntity.setStatus(7);
////            orderEntity.setFromType(2);
////            orderEntity.setDealStatus(3);
////            orderEntity.setAuditTime(new Date());
////            orderService.update(orderEntity);
////            //推送自助平台
////            spGetHttpClient.updateCheckStatus(orderEntity, collectOrder.getCreateUser());

            IoOrderEntity orderEntity = orderService.findByBillNo(collectOrder.getBillNo());
            if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_CHECK_REW) {
                if (orderEntity.getFromType() == ConstantStatus.FROM_UDISP) {
                    ReviewFinishRequest reviewFinishRequest = new ReviewFinishRequest();
                    reviewFinishRequest.setOrderId(collectOrder.getBillNo());
                    ThreadUtil.execAsync(() -> {
                        BaseResponse<String> stringBaseResponse = spGetHttp.reviewOrder(reviewFinishRequest, authAdmin.getId() + "");
                    });
                }
                updateReview(authAdmin, orderEntity);
            }
        }

        if (sysWorkplaceDocumentEntity != null) {
            Integer uploadYb = sysWorkplaceDocumentEntity.getUploadYb();
            if (uploadYb == 1) {

                uploadThrid(collectOrder);
            }
        }


//        //插入处方备份表
//        IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
//        BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
//        boolean save = ioCollectOrderBackupService.save(ioCollectOrderBackup);
//        if (!save){
//            throw new JsonException(500,"处方备用上传失败");
//        }
//        List<IoCollectOrderBiz> ioCollectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
//        for (IoCollectOrderBiz ioCollectOrderBiz : ioCollectOrderBizs){
//            IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
//            BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
//            boolean save1 = ioCollectOrderBizBackupService.save(ioCollectOrderBizBackup);
//            if (!save1){
//                throw new JsonException(500,"处方备用明细上传失败");
//            }
//        }
    }

    /**
     * 构建内部单据
     */
    public void buildInnerOrder(IoCollectOrderBackup collectOrder, SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity) {
        List<IoCollectOrderCodeMan> collectOrderCodes = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
        BasicBussinessTypeEntity bussinessTypeEntity;
        sysWorkplaceDocumentEntity.getInoutType();

        //构造单据数据
        IoOrderEntity orderEntity = new IoOrderEntity();
        bussinessTypeEntity = bussinessTypeService.findByAction(sysWorkplaceDocumentEntity.getDocumentTypeCode());
        orderEntity.setMainAction(bussinessTypeEntity.getMainAction());
        orderEntity.setAction(bussinessTypeEntity.getAction());
        orderEntity.setCreateTime(new Date());
        if (IntUtil.value(sysWorkplaceDocumentEntity.getCorpType()) == 2) {
            orderEntity.setInvCode(collectOrder.getShipper() + "");
            orderEntity.setFromCorp(collectOrder.getFromCorp());
            InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByInvSubByCode(orderEntity.getInvCode() + "");
            if (invWarehouseEntity != null) orderEntity.setDeptCode(invWarehouseEntity.getParentId());
        } else {
            orderEntity.setInvCode(collectOrder.getFromCorp() + "");
            orderEntity.setFromCorp(collectOrder.getShipper());
            InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByInvSubByCode(orderEntity.getInvCode() + "");
            if (invWarehouseEntity != null) orderEntity.setDeptCode(invWarehouseEntity.getParentId());
        }

        orderEntity.setCorpOrderId(CustomUtil.getId() + "x");
        orderEntity.setExportStatus(0);
        orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_PROCESS);
        orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_DRAFT);
        orderEntity.setCreateUser(collectOrder.getCreateUser());
        orderEntity.setCreateTime(new Date());
        orderEntity.setUpdateUser(collectOrder.getCreateUser());
        orderEntity.setUpdateTime(new Date());
        orderEntity.setCustomerId("110");
        orderEntity.setOrderType(2);
        orderEntity.setProductType(bussinessTypeEntity.getProductType());
        orderEntity.setFromType(2);
        String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
        orderEntity.setBillNo(orderNo);
        List<IoCodeTempEntity> lossCodesList = new ArrayList<>();

        for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodes) {
            lossCodesList.add(buildCodeEntity(collectOrderCodeMan, orderEntity));
        }

        /**
         * 如果单据类型为供应商的话，则进行供应商产品绑定
         */
        if (bussinessTypeEntity.getCorpType() == ConstantStatus.CORP_SP) {

            Map<Long, List<IoCodeTempEntity>> groupedMap = lossCodesList.stream().collect(Collectors.groupingBy(IoCodeTempEntity::getRelId));
            groupedMap.forEach((key, value) -> {
                companyProductRelevanceService.insertOrReadId(key, collectOrder.getShipper());
            });
            for (IoCodeTempEntity codeTempEntity : lossCodesList) {
                codeTempEntity.setSupId(collectOrder.getShipper());
            }
        }
        orderService.insertOrder(orderEntity);
        codesTempDao.insertBatch(lossCodesList);
        addInoutService.dealProcess(orderEntity);
        if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
            ioCheckInoutService.check(orderEntity.getBillNo());
        }
    }

    @Resource
    SysWorkplaceBusMapper sysWorkplaceBusMapper;
    @Resource
    SysWorkplaceService sysWorkplaceService;
    @Resource
    InvWarehouseDao invWarehouseDao;

    public void uploadInnerOrder(IoCollectOrderBackup collectOrder, SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity) {
        List<IoCollectOrderCodeMan> collectOrderCodes = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
        BasicBussinessTypeEntity bussinessTypeEntity;
        sysWorkplaceDocumentEntity.getInoutType();

        InvWarehouseEntity invWarehouseEntity = null;
        SysWorkplaceBus sysWorkplaceBus = sysWorkplaceBusMapper.selectOne(new LambdaQueryWrapper<SysWorkplaceBus>().eq(SysWorkplaceBus::getBusTypeCode, sysWorkplaceDocumentEntity.getDocumentTypeCode()).last("limit 1"));
        if (sysWorkplaceBus != null) {
            SysWorkplace sysWorkplace = sysWorkplaceService.getWorkplace(sysWorkplaceBus.getWorkplaceCode());
            if (sysWorkplace != null) {
                String deptCode = sysWorkplace.getDeptCode();
                invWarehouseEntity = invWarehouseDao.selectOne(new LambdaQueryWrapper<InvWarehouseEntity>().eq(InvWarehouseEntity::getParentId, deptCode).last("limit 1"));
            }
        }
        if (invWarehouseEntity == null) {
            throw new JsonException(500, "未找到科室");
        }
        //构造单据数据
        IoOrderEntity orderEntity = new IoOrderEntity();
        bussinessTypeEntity = bussinessTypeService.findByAction(sysWorkplaceDocumentEntity.getUploadDocumentTypeCode());
        orderEntity.setMainAction(bussinessTypeEntity.getMainAction());
        orderEntity.setAction(bussinessTypeEntity.getAction());
        orderEntity.setPreInBillNo(collectOrder.getPreInBillNo());
        orderEntity.setCreateTime(new Date());
        if (IntUtil.value(sysWorkplaceDocumentEntity.getCorpType()) == 2) {
            orderEntity.setInvCode(invWarehouseEntity.getCode());
            orderEntity.setFromCorp(collectOrder.getFromCorp());
        } else {
            orderEntity.setInvCode(invWarehouseEntity.getCode());
            orderEntity.setFromCorp(addInoutService.updateCorp(bussinessTypeEntity, collectOrder.getFromCorp(), collectOrder.getFromCorp()));
        }
        if (invWarehouseEntity != null) {
            orderEntity.setDeptCode(invWarehouseEntity.getParentId());
        }
        orderEntity.setCorpOrderId(CustomUtil.getId() + "x");
        orderEntity.setExportStatus(0);
        orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_PROCESS);
        orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_DRAFT);
        orderEntity.setCreateUser(collectOrder.getCreateUser());
        orderEntity.setCreateTime(new Date());
        orderEntity.setUpdateUser(collectOrder.getCreateUser());
        orderEntity.setUpdateTime(new Date());
        orderEntity.setCustomerId("110");
        orderEntity.setOrderType(2);
        orderEntity.setProductType(bussinessTypeEntity.getProductType());
        orderEntity.setFromType(2);
        String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
        orderEntity.setBillNo(orderNo);
        List<IoCodeTempEntity> lossCodesList = new ArrayList<>();
        for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodes) {
            lossCodesList.add(buildCodeEntity(collectOrderCodeMan, orderEntity));
        }
        List<IoCollectOrderCodeAuto> collectOrderCodeAutos = collectOrderCodeAutoService.listByBillNo(collectOrder.getBillNo(), null);

        for (IoCollectOrderCodeAuto collectOrderCodeAuto : collectOrderCodeAutos) {
            lossCodesList.add(buildAutoCodeEntity(collectOrderCodeAuto, orderEntity));
        }
        /**
         * 如果单据类型为供应商的话，则进行供应商产品绑定
         */
        if (bussinessTypeEntity.getCorpType() == ConstantStatus.CORP_SP) {

            Map<Long, List<IoCodeTempEntity>> groupedMap = lossCodesList.stream().collect(Collectors.groupingBy(IoCodeTempEntity::getRelId));
            groupedMap.forEach((key, value) -> {
                companyProductRelevanceService.insertOrReadId(key, collectOrder.getShipper());
            });
            for (IoCodeTempEntity codeTempEntity : lossCodesList) {
                codeTempEntity.setSupId(collectOrder.getShipper());
            }
        }
        orderService.insertOrder(orderEntity);
        codesTempDao.insertBatch(lossCodesList);
        addInoutService.dealProcess(orderEntity);
        if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
            ioCheckInoutService.check(orderEntity.getBillNo());
        }
    }


    public void updateSpmsOrder(String billNo, AuthAdmin authAdmin) {
        IoOrderEntity orderEntity = orderService.findByBillNo(billNo);
        if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_CHECK_REW) {
            if (orderEntity.getFromType() == ConstantStatus.FROM_UDISP) {
                ReviewFinishRequest reviewFinishRequest = new ReviewFinishRequest();
                reviewFinishRequest.setOrderId(billNo);
                ThreadUtil.execAsync(() -> {
                    BaseResponse<String> stringBaseResponse = spGetHttp.reviewOrder(reviewFinishRequest, authAdmin.getId() + "");
                });
            }
            updateReview(authAdmin, orderEntity);
        }
    }

    public void uploadThrid(IoCollectOrderBackup collectOrder) {
        //todo  根据单据类型上传医保或者第三方系统
        PostCollectOrderRequest orderRequest = new PostCollectOrderRequest();
        orderRequest.setThirdSys("thirdId");
        orderRequest.setWebTitle(WEB_TITLE);
        CollectOrderBizRequest collectOrderBizRequest = new CollectOrderBizRequest();
        collectOrderBizRequest.setOrderIdFk(collectOrder.getBillNo());
        List<CollectOrderBizResponse> collectOrderBizResponses = combieOrderDetail(collectOrderBizRequest);
        collectOrder.setCollectOrderBizResponseList(collectOrderBizResponses);
        List<IoCollectCodeBackup> list = ioCollectCodeBackService.list(new LambdaQueryWrapper<IoCollectCodeBackup>().eq(IoCollectCodeBackup::getBillNo, collectOrder.getBillNo()));
        collectOrder.setCodeList(list);
        List<IoCollectOrderBackup> collectOrderList = new ArrayList<>();
        collectOrderList.add(collectOrder);
        orderRequest.setCollectOrderList(collectOrderList);
        // 判断此单据 有没有码已经上传过了一个有上传就进行错误返回
        String paramValue = systemParamConfigService.selectValueByParamKey("checkCodeUploading");
        for (CollectOrderBizResponse collectOrderBizResponse : orderRequest.getCollectOrderList().get(0).getCollectOrderBizResponseList()) {
            long count = ioCollectCodeBackService.count(
                    new QueryWrapper<IoCollectCodeBackup>()
                            .eq("billNo", collectOrderBizResponse.getBillNo())
                            .eq("fifoSplit", "1").or().eq("fifoSplit", "4")
                            .last("limit 1")
            );
            if (count > 0) {
                collectOrderBizResponse.setTrdnFlag("1");
            } else {
                collectOrderBizResponse.setTrdnFlag("0");

            }
        }

        if (StrUtil.isNotEmpty(paramValue) && paramValue.equals("0")) {
            List<String> codeList = new ArrayList<>();
            for (CollectOrderBizResponse collectOrderBizResponse : collectOrderBizResponses) {
                String[] codes = collectOrderBizResponse.getFinishUdiCode().split(",");
                // 遍历fruits数组
                for (String code : codes) {
                    if (StrUtil.isNotBlank(code)) {
                        List<RelCodeDetail> relCodeDetailList = relCodeDetailService.getAllNext(code);
                        if (relCodeDetailList != null && relCodeDetailList.size() > 0) {
                            for (RelCodeDetail relCodeDetail : relCodeDetailList) {
                                codeList.add(relCodeDetail.getCurCode());
                            }
                        }
                    }
                }
            }
            BaseResponse<List> baseResponseCheckCode = erpBasicClient.collectOrderCheckCodeUploading(codeList);
            if (baseResponseCheckCode.getCode() == 20000) {
                List listCheckCode = baseResponseCheckCode.getData();
                if (listCheckCode == null || listCheckCode.size() > 0) {
                    log.error("单据的所有码有已经传输过医保的，请核实");
                    throw new JsonException("此单据的所有码有已经传输过医保的，请核实" + baseResponseCheckCode.getMessage());
                }
            } else {
                throw new JsonException("查询码关联关系服务出错，" + baseResponseCheckCode.getMessage());
            }
        }
        // 医保上传
        BaseResponse baseResponse = erpBasicClient.postOrder(orderRequest);
        if (baseResponse.getCode() == 20000) {
            // 触发上传 转发至中继服务 到外网 再到国家同步库
            ThreadUtil.execAsync(() -> {
                BaseResponse<String> stringBaseResponse = new BaseResponse<>();
                try {
                    stringBaseResponse = erpBasicClient.collectOrderUpload(orderRequest);
                } catch (Exception e) {
                    throw new JsonException("触发上传 转发至中继服务 到外网 再到国家同步库 接口服务出错：" + stringBaseResponse.getMessage());
                }
            });
        } else {
            throw new JsonException("连接第三方系统接口服务出错，" + baseResponse.getMessage());
        }
//        if (baseResponse.getCode() == 520) {
//            Log.error("上传失败，" + baseResponse.getMessage());
//        } else {
//            throw new JsonException("连接第三方系统接口服务出错，" + baseResponse.getMessage());
//        }

    }


    @Resource
    UdiRlSupService udiRlSupService;

    private IoCodeTempEntity buildCodeEntity(IoCollectOrderCodeMan collectOrderCodeMan, IoOrderEntity orderEntity) {
        IoCodeTempEntity tempEntity = new IoCodeTempEntity();
        tempEntity.setOrderId(orderEntity.getBillNo());
        tempEntity.setCode(collectOrderCodeMan.getUdiCode());
        tempEntity.setRelId(collectOrderCodeMan.getRelId());
        tempEntity.setMainAction(orderEntity.getMainAction());
        tempEntity.setInvCode(orderEntity.getInvCode());
        tempEntity.setBatchNo(collectOrderCodeMan.getBatchNo());
        tempEntity.setProduceDate(collectOrderCodeMan.getProductDate());
        tempEntity.setExpireDate(collectOrderCodeMan.getExpireDate());
        tempEntity.setSerialNo(collectOrderCodeMan.getSerialNo());
        tempEntity.setNameCode(collectOrderCodeMan.getNameCode());
        tempEntity.setCount(collectOrderCodeMan.getScanCount());
        tempEntity.setReCount(collectOrderCodeMan.getScanCount());
        tempEntity.setCreateTime(new Date());
        tempEntity.setUpdateTime(new Date());
        CompanyProductRelevanceEntity udiRlSupEntity = udiRlSupService.selOneByRlId(tempEntity.getRelId());
        if (udiRlSupEntity != null) tempEntity.setSupId(udiRlSupEntity.getCustomerId());
        tempEntity.setDeptCode(orderEntity.getDeptCode());
        return tempEntity;
    }

    //todo 这个有问题，自动赋码还有数据没补齐
    private IoCodeTempEntity buildAutoCodeEntity(IoCollectOrderCodeAuto collectOrderCodeMan, IoOrderEntity orderEntity) {
        IoCodeTempEntity tempEntity = new IoCodeTempEntity();
        tempEntity.setOrderId(orderEntity.getBillNo());
        tempEntity.setCode(collectOrderCodeMan.getUdiCode());
        tempEntity.setRelId(collectOrderCodeMan.getRelId());
        tempEntity.setMainAction(orderEntity.getMainAction());
        tempEntity.setInvCode(orderEntity.getInvCode());
        tempEntity.setBatchNo(collectOrderCodeMan.getBatchNo());
        tempEntity.setProduceDate(collectOrderCodeMan.getProductDate());
        tempEntity.setExpireDate(collectOrderCodeMan.getExpireDate());
        tempEntity.setSerialNo(collectOrderCodeMan.getSerialNo());
        tempEntity.setNameCode(collectOrderCodeMan.getUdiCode());
        tempEntity.setCount(1);
        tempEntity.setReCount(1);
        tempEntity.setCreateTime(new Date());
        tempEntity.setUpdateTime(new Date());
        CompanyProductRelevanceEntity udiRlSupEntity = udiRlSupService.selOneByRlId(tempEntity.getRelId());
        if (udiRlSupEntity != null) tempEntity.setSupId(udiRlSupEntity.getCustomerId());
        tempEntity.setDeptCode(orderEntity.getDeptCode());
        return tempEntity;
    }


    @Transactional(rollbackFor = Exception.class, isolation = Isolation.READ_COMMITTED)
    public Boolean orderUpload(String billNo, AuthAdmin authAdmin) {
        IoCollectOrderBackup updateOrder = new IoCollectOrderBackup();
        updateOrder.setBillNo(billNo);
        try {

            this.generateOrder(billNo, authAdmin);
            updateOrder.setUploadStatus(2);
        } catch (Exception e) {
            updateOrder.setUploadStatus(3);
            updateOrder.setUploadError(e.getMessage());
        }
//        // 上传医保时间修改
        updateOrder.setUploadYbTime(new Date());
        //
        //更新状态
        this.updateByBillNo(updateOrder);
        if (updateOrder.getUploadStatus() == 3) {
            return false;
        }
        return true;
    }

    public List<IoCollectOrderCodeMan> codeDetail(Long bizIdFk) {
        List<IoCollectOrderCodeMan> reList = new ArrayList<>();

        List<IoCollectOrderCodeAuto> splitCodes = collectOrderCodeAutoService.list(new LambdaQueryWrapper<IoCollectOrderCodeAuto>().eq(IoCollectOrderCodeAuto::getBizIdFk, bizIdFk));
        List<IoCollectOrderCodeMan> manList = collectOrderCodeManService.list(new LambdaQueryWrapper<IoCollectOrderCodeMan>().eq(IoCollectOrderCodeMan::getBizIdFk, bizIdFk));

        if (CollUtil.isNotEmpty(splitCodes)) {
            splitCodes.forEach(item -> {
                IoCollectOrderCodeMan ioCollectOrderCodeMan = new IoCollectOrderCodeMan();
                BeanUtils.copyProperties(item, ioCollectOrderCodeMan);
                reList.add(ioCollectOrderCodeMan);
            });
        }

        if (CollUtil.isNotEmpty(manList)) {
            manList.forEach(item -> {
                reList.add(item);
            });
        }
        return reList;
    }

    public BaseResponse updateReview(AuthAdmin authAdmin, IoOrderEntity orderEntity) {
        orderEntity.setStatus(ConstantStatus.ORDER_STATUS_AUDITED);
        orderEntity.setReviewUser((authAdmin.getId() + ""));
        orderEntity.setUpdateTime(new Date());
        orderEntity.setAuditTime(new Date());
        orderService.update(orderEntity);
        redisUtil.del(ConstantStatus.REDIS_BILLNO + orderEntity.getBillNo());
        redisUtil.del(ConstantStatus.REDIS_BILLNO_CODES + orderEntity.getBillNo());
        //验收完成->进入流程
        ioCheckInoutService.checkSecond(orderEntity);
        return ResultVOUtils.success("更新成功");
    }


//    public List<CollectOrderBizResponse>  setScanCodeOrderDetail(CollectOrderBizRequest collectOrderBizRequest) {
//        List<CollectOrderBizResponse> list = ioCollectOrderBizBackupService.filterListByBillNo(collectOrderBizRequest);
//        List<IoCollectCodeBackup> ioCollectCodeBackups = ioCollectCodeBackService.listByBillNo(collectOrderBizRequest.getOrderIdFk());;
//        List<CollectOrderBizResponse> collectOrderBizResponses = new ArrayList<>();
//        for (CollectOrderBizResponse collectOrderBiz : list) {
//            CollectOrderBizResponse collectOrderBizResponse = new CollectOrderBizResponse();
//            BeanUtils.copyProperties(collectOrderBiz, collectOrderBizResponse);
//            //查询手动赋码的code
//            for (IoCollectCodeBackup ioCollectCodeBackup : ioCollectCodeBackups) {
//                UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(collectOrderBizResponse.getNameCode());
//                if (ioCollectCodeBackup.getRelId().equals(udiRelevanceResponse.getId())) {
//                    collectOrderBizResponse.setScanUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getScanUdiCode()) + "," + ioCollectCodeBackup.getCode());
//                }
//            }
//            if (StrUtil.isNotEmpty(collectOrderBizResponse.getScanUdiCode())){
//                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getScanUdiCode() == null ? "" : collectOrderBizResponse.getScanUdiCode().substring(1));
//            }
//            collectOrderBizResponses.add(collectOrderBizResponse);
//        }
//
//        return collectOrderBizResponses;
//    }

    public List<CollectOrderBizResponse> setScanCodeOrderDetail(CollectOrderBizRequest collectOrderBizRequest) {
        List<CollectOrderBizResponse> list = ioCollectOrderBizBackupService.filterListByBillNo(collectOrderBizRequest);
        List<IoCollectCodeBackup> ioCollectCodeBackups = ioCollectCodeBackService.listByBillNo(collectOrderBizRequest.getOrderIdFk());
        List<CollectOrderBizResponse> collectOrderBizResponses = new ArrayList<>();
        Map<String, UdiRelevanceResponse> udiRelevanceMap = new HashMap<>();

        for (CollectOrderBizResponse collectOrderBiz : list) {
            udiRelevanceMap.put(collectOrderBiz.getNameCode(), udiRelevanceService.selectByNameCode(collectOrderBiz.getNameCode()));
        }

        for (CollectOrderBizResponse collectOrderBiz : list) {
            CollectOrderBizResponse collectOrderBizResponse = new CollectOrderBizResponse();
            BeanUtils.copyProperties(collectOrderBiz, collectOrderBizResponse);

            UdiRelevanceResponse udiRelevanceResponse = udiRelevanceMap.get(collectOrderBizResponse.getNameCode());
            if (udiRelevanceResponse != null) {
//                for (IoCollectCodeBackup ioCollectCodeBackup : ioCollectCodeBackups) {
//                    if (ioCollectCodeBackup.getRelId().equals(udiRelevanceResponse.getId())) {
//                        collectOrderBizResponse.setScanUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getScanUdiCode()) + "," + ioCollectCodeBackup.getCode());
//                    }
//                }
//                if (StrUtil.isNotEmpty(collectOrderBizResponse.getScanUdiCode())) {
//                    collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getScanUdiCode() == null ? "" : collectOrderBizResponse.getScanUdiCode().substring(1));
//                }
            }
            collectOrderBizResponses.add(collectOrderBizResponse);
        }

        return collectOrderBizResponses;
    }

    /**
     * 计算上传率
     */
    public void calculatedUploadRate(CollectOrderUploadCountRequest collectOrderUploadCountRequest, CollectOrderUploadCountResponse collectOrderUploadCountResponse) {
        List<IoCollectOrderResponse> list = ioCollectOrderBackupMapper.getList(collectOrderUploadCountRequest);
        Map<String, String[]> buyTypeMap = new HashMap<>();
        Integer buyerScanCount = 0;
        Integer salesScanCount = 0;
        Integer buyerScanCountReturn = 0;
        Integer salesScanCountReturn = 0;
        Integer buyerScanSumCount = 0;
        Integer salesScanSumCount = 0;
        Integer buyerScanSumCountReturn = 0;
        Integer salesScanSumCountReturn = 0;
        BigDecimal buyerCentage = new BigDecimal(0);
        BigDecimal salesCentage = new BigDecimal(0);
        Integer codeCount = 0;
        Integer fifoSplitOneCount = 0;
        Integer fifoSplitTwoCount = 0;
        String sum = "_sum";
        if (list != null && list.size() > 0) {
            BaseResponse<Map<String, String[]>> baseResponse = erpBasicClient.getBuyType("thirdId");
            if (baseResponse.getCode() == 20000) {
                buyTypeMap = baseResponse.getData();
            }
            Map<String, Integer> map = new HashMap();
            for (Map.Entry<String, String[]> entry : buyTypeMap.entrySet()) {
                String key = entry.getKey();
                if (ArrayUtil.isEmpty(entry.getValue())) {
                    continue;
                }
                String result = String.join(", ", entry.getValue());
                int sumCount = 0;
                int okCount = 0;

                for (IoCollectOrderResponse collectOrderResponse : list) {
                    if (result.contains(collectOrderResponse.getBusType())) {
                        if (collectOrderResponse.getRelCodeCount() != null) {
                            if (2 == collectOrderResponse.getUploadStatus()) {
                                okCount += collectOrderResponse.getRelCodeCount();
                            }
                            sumCount += collectOrderResponse.getRelCodeCount();

                        }
                    }
                }


                map.put(key , okCount);
                map.put(key + sum, sumCount);


            }
            // 数据做处理
            for (Map.Entry<String, Integer> entry : map.entrySet()) {
                String key = entry.getKey();
                Integer value = entry.getValue();

                if (key.equals("buyType_3502")) {
                    buyerScanCount += value;
                } else if (key.equals("buyType_3504")) {
                    buyerScanCountReturn += value;

                } else if (key.equals("buyType_3505")) {
                    salesScanCount += value;
                } else if (key.equals("buyType_35051")) {
                    salesScanCount += value;

                } else if (key.equals("buyType_3506")) {
                    salesScanCountReturn += value;

                }

                if (key.equals("buyType_3502" + sum)) {
                    buyerScanSumCount += value;
                } else if (key.equals("buyType_3504" + sum)) {
                    buyerScanSumCountReturn += value;

                } else if (key.equals("buyType_3505" + sum)) {
                    salesScanSumCount += value;
                } else if (key.equals("buyType_35051" + sum)) {
                    salesScanSumCount += value;

                } else if (key.equals("buyType_3506" + sum)) {
                    salesScanSumCountReturn += value;

                }
            }
        }


        collectOrderUploadCountResponse.setBuyerCentage(buyerCentage);
        collectOrderUploadCountResponse.setSalesCentage(salesCentage);

        collectOrderUploadCountResponse.setBuyerScanCount(buyerScanCount);
        collectOrderUploadCountResponse.setSalesScanCount(salesScanCount);
        collectOrderUploadCountResponse.setBuyerScanCountReturn(buyerScanCountReturn);
        collectOrderUploadCountResponse.setSalesScanCountReturn(salesScanCountReturn);

        collectOrderUploadCountResponse.setBuyerScanSumCount(buyerScanSumCount);
        collectOrderUploadCountResponse.setSalesScanSumCount(salesScanSumCount);
        collectOrderUploadCountResponse.setBuyerScanSumCountReturn(buyerScanSumCountReturn);
        collectOrderUploadCountResponse.setSalesScanSumCountReturn(salesScanSumCountReturn);


        collectOrderUploadCountResponse.setCodeCount(codeCount);
        collectOrderUploadCountResponse.setFifoSplitOneCount(fifoSplitOneCount);
        collectOrderUploadCountResponse.setFifoSplitTwoCount(fifoSplitTwoCount);

    }

    @Resource
    private BasicProductsDao basicProductsDao;
    public List<IoCollectOrderResponse> filterorderStatsList(CollectOrderRequest collectOrderRequest) {
        if (collectOrderRequest.getPage() != null) {
            int offset = (collectOrderRequest.getPage() - 1) * collectOrderRequest.getLimit();
            PageHelper.offsetPage(offset, collectOrderRequest.getLimit());
        }

        List<IoCollectOrderResponse> data = ioCollectOrderBackupMapper.filterorderStatsList(collectOrderRequest);
        for (IoCollectOrderResponse ioCollectOrderResponse : data) {

            ioCollectOrderResponse.setScanRate(getScanRate(ioCollectOrderResponse.getScanCount(), ioCollectOrderResponse.getShouldCount()));

        }

      return data;

    }

    public Integer getCount(IoCollectOrderBizBackup collectOrderBizResponse){
        Integer shouldCount = 0;
        List<BasicProductsEntity> productList = basicProductsDao.selectList(
                new LambdaQueryWrapper<BasicProductsEntity>()
                        .eq(BasicProductsEntity::getYbbm, collectOrderBizResponse.getYbbm())
                        .eq(BasicProductsEntity::getPackLevel, "1"));
        BasicProductsEntity product = productList.get(0);
        Integer myBhxjsl = product.getBhxjsl();

        double quotient = (double) collectOrderBizResponse.getCount() / myBhxjsl;
        int integerPart = (int) quotient;
        if (quotient == integerPart) {
            if (integerPart == 0) {
                if (collectOrderBizResponse.getAutoTagStatus() != 2) {
                    shouldCount = 1;
                }
            } else {
                shouldCount = integerPart;
            }
        } else {
            if (IntUtil.value(collectOrderBizResponse.getAutoTagStatus()) == 2) {
                shouldCount = 0;
            } else {
                shouldCount = integerPart + 1;
            }
        }
        return shouldCount;
    }

    public String getScanRate(Integer scanCount,Integer shouldCount) {
        if (scanCount == null || scanCount == 0) {
            return  0.00 + "%" ; // 或返回 null 根据业务需求
        }
        double v = BigDecimal.valueOf(shouldCount)
                .divide(BigDecimal.valueOf(scanCount), 4, RoundingMode.HALF_UP)
                .multiply(BigDecimal.valueOf(100))
                .setScale(2, RoundingMode.HALF_UP)
                .doubleValue();
        DecimalFormat df = new DecimalFormat("#.00");
        return df.format(v) + "%";
    }
}