package com.glxp.api.service.collect;


import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
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.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.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.CompanyProductRelevanceEntity;
import com.glxp.api.entity.basic.SysWorkplaceDocumentEntity;
import com.glxp.api.entity.collect.*;
import com.glxp.api.entity.inout.IoCodeEntity;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.system.SystemParamConfigEntity;
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.IoCollectCodeRequest;
import com.glxp.api.req.collect.PostCollectOrderRequest;
import com.glxp.api.req.inout.ReviewFinishRequest;
import com.glxp.api.res.basic.BasicSkPrescribeResponse;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.res.collect.CollectOrderBizResponse;
import com.glxp.api.res.collect.IoCollectCodeResponse;
import com.glxp.api.res.collect.IoCollectOrderResponse;
import com.glxp.api.service.auth.InvWarehouseService;
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.jfree.util.Log;
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.Transactional;

import javax.annotation.Resource;
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 int updateByBillNo(IoCollectOrderBackup collectOrder) {
        return ioCollectOrderBackupMapper.update(collectOrder, new UpdateWrapper<IoCollectOrderBackup>().eq("billNo", collectOrder.getBillNo()));
    }

    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));
            }

            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());
        //1.内部系统，且单据为扫码生成业务单则创建系统单据
        if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() == 1) {
            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());
            }
        } 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 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");
        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);
        log.debug("单据返回=========" + baseResponse);
        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;
    }


    @Transactional(rollbackFor = Exception.class)
    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.setUpdateTime(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;
    }
}