package com.glxp.api.service.inout;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.glxp.api.constant.Constant;
import com.glxp.api.dao.inout.IoSplitCodeMapper;
import com.glxp.api.entity.basic.SysWorkplacePutRel;
import com.glxp.api.entity.basic.UdiRelevanceEntity;
import com.glxp.api.entity.collect.*;
import com.glxp.api.entity.inout.IoSplitCodeEntity;
import com.glxp.api.entity.inout.IoSplitFifoCodeEntity;
import com.glxp.api.entity.inout.IoSplitFifoInv;
import com.glxp.api.exception.JsonException;
import com.glxp.api.req.basic.FilterUdiRelRequest;
import com.glxp.api.req.collect.AddInvDesDetaiRequest;
import com.glxp.api.req.inout.IoSplitCodeRequest;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.collect.*;
import com.glxp.api.service.thrsys.SysWorkplacePutRelService;
import com.glxp.api.util.GennerOrderUtils;
import com.glxp.api.util.IntUtil;
import com.glxp.api.util.OrderNoTypeBean;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class IoSplitCodeService extends ServiceImpl<IoSplitCodeMapper, IoSplitCodeEntity> {

    @Resource
    IoSplitCodeMapper splitCodeMapper;
    @Resource
    IoSplitFifoCodeService splitFifoCodeService;
    @Resource
    IoCollectOrderBizService collectOrderBizService;
    @Resource
    IoCollectOrderCodeAutoService collectOrderCodeAutoService;
    @Resource
    IoSplitDesOrderService splitDesOrderService;
    @Resource
    IoSplitDesOrderDetailService splitDesOrderDetailService;
    @Resource
    GennerOrderUtils gennerOrderUtils;

    public List<IoSplitCodeEntity> filterList(IoSplitCodeRequest splitCodeRequest) {
        if (splitCodeRequest == null) {
            return Collections.emptyList();
        }
        if (splitCodeRequest.getPage() != null) {
            int offset = (splitCodeRequest.getPage() - 1) * splitCodeRequest.getLimit();
            PageHelper.offsetPage(offset, splitCodeRequest.getLimit());
        }
        return super.baseMapper.filterList(splitCodeRequest);

    }

    public List<IoSplitCodeEntity> findSplitCodes(Long relId, String batchNo, Long workPlaceCode) {
        List<IoSplitCodeEntity> ioSplitCodeEntities = splitCodeMapper.selectList(new LambdaQueryWrapper<IoSplitCodeEntity>()
                .eq(IoSplitCodeEntity::getRelId, relId)
                .eq(StrUtil.isNotEmpty(batchNo), IoSplitCodeEntity::getBatchNo, batchNo)
                .eq(workPlaceCode != null, IoSplitCodeEntity::getWorkPlaceCode, workPlaceCode)
                .in(IoSplitCodeEntity::getStatus, 1, 2).orderByAsc(IoSplitCodeEntity::getInBactchNo));
        return ioSplitCodeEntities;
    }

    public IoSplitCodeEntity findByCode(String code, Long workPlaceCode, String busType) {
        List<IoSplitCodeEntity> ioSplitCodeEntities = splitCodeMapper.selectList(new LambdaQueryWrapper<IoSplitCodeEntity>()
                .eq(IoSplitCodeEntity::getCode, code)
                .eq(workPlaceCode != null, IoSplitCodeEntity::getWorkPlaceCode, workPlaceCode)
                .in(IoSplitCodeEntity::getStatus, 1, 2).orderByAsc(IoSplitCodeEntity::getInBactchNo));
        if (CollUtil.isNotEmpty(ioSplitCodeEntities))
            return ioSplitCodeEntities.get(0);
        return null;
    }

    public void splitRemove(IoCollectOrderBiz collectOrderBiz, IoCollectOrder collectOrder, Long putWorkPlaceCode) {
        //1.按照先进先出原则，查询拆零表，获取拆零表ID
        List<IoSplitCodeEntity> ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), putWorkPlaceCode);

        //2.如果拆零表为空，则自动从预出库队列中获拉取数据
        if (CollUtil.isEmpty(ioSplitCodeEntities)) {
            addFifoCode(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), IntUtil.value(collectOrderBiz.getCount()));
            ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), putWorkPlaceCode);
        }
        //3.如果拆零表不为空，则开始扣除数量
        int count = 0;
        int unCount = 0;  //剩余未扣减数量
        unCount = IntUtil.value(collectOrderBiz.getUnTagCount());
        for (IoSplitCodeEntity ioSplitCodeEntity : ioSplitCodeEntities) {
            count = IntUtil.value(ioSplitCodeEntity.getRemainCount()) - unCount;
            collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
                    .codeIdFk(ioSplitCodeEntity.getId())
                    .udiCode(ioSplitCodeEntity.getCode())
                    .orderIdFk(collectOrder.getBillNo())
                    .batchNo(ioSplitCodeEntity.getBatchNo())
                    .productDate(ioSplitCodeEntity.getProduceDate())
                    .expireDate(ioSplitCodeEntity.getExpireDate())
                    .serialNo(ioSplitCodeEntity.getSerialNo())
                    .relId(collectOrderBiz.getRelId())
                    .bizIdFk(collectOrderBiz.getId())
                    .fifoSplit(ioSplitCodeEntity.getFifoSplit())
                    .createTime(new Date())
                    .updateTime(new Date())
                    .build());
            if (count > 0) {
                ioSplitCodeEntity.setRemainCount(count);
                unCount = 0;
                splitCodeMapper.updateById(ioSplitCodeEntity);
                break;
            } else if (count == 0) {
                ioSplitCodeEntity.setRemainCount(0);
                unCount = 0;
            } else {
                ioSplitCodeEntity.setRemainCount(0);
                unCount = -count;
            }
            splitCodeMapper.updateById(ioSplitCodeEntity);
        }

        if (unCount > 0) {
            //4.拆零表数量不足，则从预出库队列中获取数据
            Integer fifoCount = addFifoCode(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), unCount);
            if (fifoCount == 0) {
                //预出库队列数量不足
                collectOrderBiz.setTagStatus(2);
                collectOrderBiz.setTagMsg("预出库队列码数量不足，赋码失败！");
                return;
//                throw new JsonException(500, "提交失败，工位库存数量不足！");
            } else {
                //再次执行赋码
                ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), putWorkPlaceCode);
                for (IoSplitCodeEntity ioSplitCodeEntity : ioSplitCodeEntities) {
                    count = IntUtil.value(ioSplitCodeEntity.getRemainCount()) - unCount;
                    collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
                            .codeIdFk(ioSplitCodeEntity.getId())
                            .udiCode(ioSplitCodeEntity.getCode())
                            .orderIdFk(collectOrder.getBillNo())
                            .batchNo(ioSplitCodeEntity.getBatchNo())
                            .productDate(ioSplitCodeEntity.getProduceDate())
                            .expireDate(ioSplitCodeEntity.getExpireDate())
                            .serialNo(ioSplitCodeEntity.getSerialNo())
                            .relId(collectOrderBiz.getRelId())
                            .bizIdFk(collectOrderBiz.getId())
                            .fifoSplit(ioSplitCodeEntity.getFifoSplit())
                            .createTime(new Date())
                            .updateTime(new Date())
                            .build());
                    if (count > 0) {
                        ioSplitCodeEntity.setRemainCount(count);
                        break;
                    } else if (count == 0) {
                        ioSplitCodeEntity.setRemainCount(0);
                    } else {
                        ioSplitCodeEntity.setRemainCount(0);
                        unCount = -count;
                    }
                }
                if (unCount > 0) {
                    collectOrderBiz.setTagStatus(2);
                    collectOrderBiz.setTagMsg("预出库队列码数量不足，赋码失败！");
                    return;
//                    throw new JsonException(500, "提交失败，工位库存数量不足！");
                } else {
                    collectOrderBiz.setTagStatus(3);
                    collectOrderBiz.setTagMsg("赋码完成！");
                }
            }
        } else {
            collectOrderBiz.setTagStatus(3);
            collectOrderBiz.setTagMsg("赋码完成！");
        }
        collectOrderBiz.setUnTagCount(unCount);
        collectOrderBizService.updateById(collectOrderBiz);
    }

    @Resource
    UdiRelevanceService udiRelevanceService;
    @Resource
    IoCollectOrderCodeManService collectOrderCodeManService;
    @Resource
    IoSplitCodeService splitCodeService;
    @Resource
    IoCollectOrderBizBackupService ioCollectOrderBizBackupService;

    @Transactional(rollbackFor = Exception.class)
    public void finishAutoTagCode(IoCollectOrder collectOrder) {

        SysWorkplacePutRel sysWorkplacePutRel = workplacePutRelService.findPutWorkPlace(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
        Long putWorkPlaceCode = null;
        if (sysWorkplacePutRel != null)
            putWorkPlaceCode = sysWorkplacePutRel.getWorkPlaceCode();
        List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());

        //如果手动扫码判断该码是否在队列里，如果已在队列，则队列里剔除
        List<IoCollectOrderCodeMan> collectOrderCodeMEN = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
        if (CollUtil.isNotEmpty(collectOrderCodeMEN)) {
            for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodeMEN) {
                IoSplitFifoCodeEntity splitFifoCodeEntity = splitFifoCodeService.findByCode(collectOrderCodeMan.getUdiCode(), putWorkPlaceCode);
                if (splitFifoCodeEntity != null) {
                    collectOrderCodeMan.setRemoveFlag(true);
                    if (IntUtil.value(splitFifoCodeEntity.getScanCount()) - IntUtil.value(collectOrderCodeMan.getScanCount()) <= 0) {
                        splitFifoCodeService.removeById(splitFifoCodeEntity.getId());
                        IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
                        if (splitFifoInv != null) {
                            splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(splitFifoCodeEntity.getTotalCount()));
                            int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoCodeEntity.getTotalCount());
                            splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
                            splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                            splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                            splitFifoInvService.updateById(splitFifoInv);
                        }

                    } else {
                        //队列码数量大于扫码数量更新数量（一般指无序列号）
//                        UdiRelevanceEntity udiRelevanceEntity = udiRelevanceService.selectById(collectOrderCodeMan.getRelId());
                        FilterUdiRelRequest filterUdiRelRequest = new FilterUdiRelRequest();
                        filterUdiRelRequest.setId(collectOrderCodeMan.getRelId());
                        filterUdiRelRequest.setPackLevel("1");
                        UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectOneUdi(filterUdiRelRequest);
                        int removeCount = IntUtil.value(collectOrderCodeMan.getScanCount()) * udiRelevanceResponse.getBhxjsl();
                        splitFifoCodeService.updateById(IoSplitFifoCodeEntity.builder()
                                .id(splitFifoCodeEntity.getId())
                                .scanCount(IntUtil.value(splitFifoCodeEntity.getScanCount()) - IntUtil.value(collectOrderCodeMan.getScanCount()))
                                .totalCount(IntUtil.value(splitFifoCodeEntity.getTotalCount()) - removeCount)
                                .build());

                        IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
                        if (splitFifoInv != null) {
                            splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + removeCount);
                            splitFifoInv.setLockCount(IntUtil.value(splitFifoInv.getLockCount()) - removeCount);
                            splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                            splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                            splitFifoInvService.updateById(splitFifoInv);
                        }
                    }
                }

            }
        }
        List<Long> removeIds = new ArrayList<>();
        for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
//            UdiRelevanceEntity udiRelevanceEntity = udiRelevanceService.selectById(collectOrderBiz.getRelId());
            FilterUdiRelRequest filterUdiRelRequest = new FilterUdiRelRequest();
            filterUdiRelRequest.setId(collectOrderBiz.getRelId());
            filterUdiRelRequest.setPackLevel("1");
            UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectOneUdi(filterUdiRelRequest);
            //去除掉已经手动扫码的数据，找出需要自动扫码的明细，执行上述的拆零或整取
            int unTagCount = collectOrderBiz.getCount() - IntUtil.value(collectOrderBiz.getScanActCount());
            if (unTagCount > 0) {
                collectOrderBiz.setUnTagCount(unTagCount);
            } else {
                collectOrderBiz.setTagStatus(3);
                //手动扫码时涉及到拆零时，把拆零剩余数量插入至拆零表里
                if (unTagCount < 0) {
                    if (IntUtil.value(udiRelevanceResponse.getBhxjsl()) > -unTagCount) {

                        Optional<IoCollectOrderCodeMan> firstMatch = collectOrderCodeMEN.stream()
                                .filter(item ->
                                        IntUtil.value(item.getRemoveFlag()) && item.getBizIdFk().equals(collectOrderBiz.getId()))
                                .findFirst();
                        IoCollectOrderCodeMan result = null;
                        if (firstMatch.isPresent()) {
                            result = firstMatch.get();
                        } else {
                            Optional<IoCollectOrderCodeMan> firstMatch1 = collectOrderCodeMEN.stream()
                                    .filter(item ->
                                            item.getBizIdFk().equals(collectOrderBiz.getId()))
                                    .findFirst();
                            if (firstMatch1.isPresent()) {
                                result = firstMatch1.get();
                            }
                        }
                        IoSplitCodeEntity ioSplitCodeEntity = IoSplitCodeEntity.builder().code(result.getUdiCode())
                                .errUdiCode(result.getUdiCode())
                                .orderId(result.getOrderIdFk())
                                .action(collectOrder.getBusType())
                                .relId(result.getRelId())
                                .nameCode(result.getNameCode())
                                .batchNo(result.getBatchNo())
                                .produceDate(result.getProductDate())
                                .expireDate(result.getExpireDate())
                                .serialNo(result.getSerialNo())
                                .scanCount(result.getScanCount())
                                .totalCount(result.getScanCount())
                                .workPlaceCode(putWorkPlaceCode)
                                .status(2)
                                .fifoSplit(1)
                                .createTime(new Date()).updateTime(new Date())
                                .remainCount(-unTagCount).build();
                        this.decorateUnpackExpireTime(ioSplitCodeEntity);
                        splitCodeService.save(ioSplitCodeEntity);
                    }

                }
                continue;
            }

            int quotient = collectOrderBiz.getUnTagCount() / IntUtil.value(udiRelevanceResponse.getBhxjsl());
            int remainder = collectOrderBiz.getUnTagCount() % IntUtil.value(udiRelevanceResponse.getBhxjsl());
            //2.如果整盒，从工位队列扣除
            if (quotient > 0) {
                List<IoSplitFifoCodeEntity> ioSplitFifoCodeEntities = splitFifoCodeService.findByRelId(putWorkPlaceCode, collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo());
                if (ioSplitFifoCodeEntities.size() < quotient) {
                    return;
//                    throw new JsonException(500, "提交失败，工位库存数量不足！");
                }
                for (int i = 0; i < quotient; i++) {
                    IoSplitFifoCodeEntity splitFifoCodeEntity = ioSplitFifoCodeEntities.get(i);
                    removeIds.add(splitFifoCodeEntity.getId());
                    collectOrderBiz.setUnTagCount(IntUtil.value(collectOrderBiz.getUnTagCount()) - IntUtil.value(udiRelevanceResponse.getBhxjsl()));
                    collectOrderCodeAutoService.save(IoCollectOrderCodeAuto.builder()
                            .codeIdFk(splitFifoCodeEntity.getId())
                            .udiCode(splitFifoCodeEntity.getCode())
                            .orderIdFk(collectOrder.getBillNo())
                            .batchNo(splitFifoCodeEntity.getBatchNo())
                            .productDate(splitFifoCodeEntity.getProduceDate())
                            .expireDate(splitFifoCodeEntity.getExpireDate())
                            .serialNo(splitFifoCodeEntity.getSerialNo())
                            .relId(collectOrderBiz.getRelId())
                            .bizIdFk(collectOrderBiz.getId())
                            .fifoSplit(splitFifoCodeEntity.getFifoSplit())
                            .createTime(new Date())
                            .updateTime(new Date())
                            .build());
                }
            }
            //.如果拆零，拆零表扣除
            if (remainder > 0) {
                splitRemove(collectOrderBiz, collectOrder, putWorkPlaceCode);
            }
        }
        ArrayList<IoCollectOrderBizBackup> ioCollectOrderBizBackups = new ArrayList<>();
        for (IoCollectOrderBiz ioCollectOrderBiz : collectOrderBizs) {
            IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
            BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
            ioCollectOrderBizBackups.add(ioCollectOrderBizBackup);
        }
        ioCollectOrderBizBackupService.saveBatch(ioCollectOrderBizBackups);

    }


    @Resource
    IoSplitFifoInvRelService splitFifoInvRelService;

    public List<Long> findInvIdFk(IoCollectOrder collectOrder) {
        List<IoSplitFifoInvRel> ioSplitFifoInvRels = splitFifoInvRelService.findInvIdFk(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
        if (CollUtil.isNotEmpty(ioSplitFifoInvRels)) {
            return ioSplitFifoInvRels.stream()
                    .map(IoSplitFifoInvRel::getInvIdFk)
                    .collect(Collectors.toList());
        } else
            return null;


    }

    @Resource
    SysWorkplacePutRelService workplacePutRelService;

    /**
     * 单据预赋码
     *
     * @param collectOrder
     */
    public void preAutoTagCode(IoCollectOrder collectOrder) {
        Long putWorkPlaceCode = null;
        //获取上货工位
        SysWorkplacePutRel sysWorkplacePutRel = workplacePutRelService.findPutWorkPlace(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
        if (sysWorkplacePutRel != null)
            putWorkPlaceCode = sysWorkplacePutRel.getWorkPlaceCode();

        List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
        for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
            List<IoSplitFifoCodeEntity> splitFifoCodeEntities =
                    splitFifoCodeService.findByRelId(putWorkPlaceCode,
                            collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo());
            int total = splitFifoCodeEntities.stream()
                    .mapToInt(IoSplitFifoCodeEntity::getTotalCount)
                    .sum();
            collectOrderBiz.setTempWorkPlaceCount(total);
            List<IoSplitCodeEntity> splitCodeEntities = splitCodeService.findSplitCodes(collectOrderBiz.getRelId()
                    , collectOrderBiz.getBatchNo(), putWorkPlaceCode);
            int splitTotal = splitCodeEntities.stream()
                    .mapToInt(IoSplitCodeEntity::getRemainCount)
                    .sum();
            collectOrderBiz.setTempSplitCount(splitTotal);
            total = total + splitTotal;
            if (total >= IntUtil.value(collectOrderBiz.getCount())) {
                collectOrderBiz.setAutoTagStatus(2);
            } else if (total > 0) {
                collectOrderBiz.setAutoTagStatus(3);
            } else
                collectOrderBiz.setAutoTagStatus(1);
        }
        collectOrderBizService.updateBatchById(collectOrderBizs);
    }


    /**
     * 拆零单据撤回，则将拆零表剩余数量加回预出库队列
     *
     * @param collectOrder
     */
    public void backSplit(IoCollectOrder collectOrder) {
        List<IoCollectOrderBiz> collectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
        for (IoCollectOrderBiz collectOrderBiz : collectOrderBizs) {
            List<IoSplitCodeEntity> ioSplitCodeEntities = findSplitCodes(collectOrderBiz.getRelId(), collectOrderBiz.getBatchNo(), collectOrder.getWorkPlaceCode());
            if (CollUtil.isNotEmpty(ioSplitCodeEntities)) {
                IoSplitCodeEntity splitCodeEntity = ioSplitCodeEntities.get(0);
                splitCodeEntity.setRemainCount(IntUtil.value(splitCodeEntity.getRemainCount()) + (IntUtil.value(collectOrderBiz.getCount()) - IntUtil.value(collectOrderBiz.getUnTagCount())));
                splitCodeMapper.updateById(splitCodeEntity);
            }
        }
    }

    @Resource
    IoSplitFifoInvService splitFifoInvService;

    /**
     * 从预出库队列里面取出数据，添加至拆零表
     */
    public Integer addFifoCode(Long relId, String batchNo, Integer needCount) {

        List<IoSplitFifoCodeEntity> splitFifoCodeEntities = splitFifoCodeService
                .list(new LambdaQueryWrapper<IoSplitFifoCodeEntity>()
                        .eq(IoSplitFifoCodeEntity::getRelId, relId)
                        .eq(StrUtil.isNotEmpty(batchNo), IoSplitFifoCodeEntity::getBatchNo, batchNo)
                        .orderByAsc(IoSplitFifoCodeEntity::getInBactchNo)
                );
        Integer count = 0;
        List<IoSplitCodeEntity> addSplitCodeEntities = new ArrayList<>();
        List<Long> removeIds = new ArrayList<>();
        for (IoSplitFifoCodeEntity splitFifoCodeEntity : splitFifoCodeEntities) {
            IoSplitCodeEntity splitCodeEntity = new IoSplitCodeEntity();
            BeanUtils.copyProperties(splitFifoCodeEntity, splitCodeEntity);

            count = IntUtil.value(splitFifoCodeEntity.getTotalCount()) + count;
            splitCodeEntity.setRemainCount(splitCodeEntity.getTotalCount());

            splitCodeEntity.setStatus(1);
            splitCodeEntity.setFifoSplit(splitFifoCodeEntity.getFifoSplit());
            splitCodeEntity.setId(null);
            this.decorateUnpackExpireTime(splitCodeEntity);
            addSplitCodeEntities.add(splitCodeEntity);
            removeIds.add(splitFifoCodeEntity.getId());
            IoSplitFifoInv splitFifoInv = splitFifoInvService.findByFifoCode(splitFifoCodeEntity);
            if (splitFifoInv != null) {
                splitFifoInv.setOutCount(IntUtil.value(splitFifoInv.getOutCount()) + IntUtil.value(splitFifoCodeEntity.getTotalCount()));
                int lockCount = IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoCodeEntity.getTotalCount());
                splitFifoInv.setLockCount(lockCount > 0 ? lockCount : 0);
                splitFifoInv.setReCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                splitFifoInv.setAvailableCount(IntUtil.value(splitFifoInv.getInCount()) - IntUtil.value(splitFifoInv.getLockCount()) - IntUtil.value(splitFifoInv.getOutCount()));
                splitFifoInvService.updateById(splitFifoInv);
            }
            if (count >= needCount) {
                break;
            }
        }
        if (removeIds.size() > 0) {
            splitFifoCodeService.removeByIds(removeIds);
        }
        if (addSplitCodeEntities.size() > 0) {
            splitCodeMapper.insertBatch(addSplitCodeEntities);
        }
        return count;

    }


    public int checkStatus(List<IoCollectOrderBiz> list) {
        boolean hasTwo = false;
        boolean hasOne = false;
        boolean hasNone = true;
        for (IoCollectOrderBiz di : list) {
            int tagStatus = di.getTagStatus();
            if (tagStatus == 2) {
                hasTwo = true;
            } else if (tagStatus == 1) {
                hasOne = true;
            } else if (tagStatus != 3) {
                throw new IllegalArgumentException("Invalid tagStatus value: " + tagStatus);
            }
        }
        for (IoCollectOrderBiz di : list) {
            if (IntUtil.value(di.getCount()) != IntUtil.value(di.getUnTagCount())) {
                hasNone = false;
                break;
            }
        }
        if (hasNone) {
            return 1;
        }
        if (hasTwo) {
            return 2;
        } else if (hasOne) {
            return 1;
        } else {
            return 3;
        }
    }


    //包装拆包失效时间
    void decorateUnpackExpireTime(IoSplitCodeEntity ioSplitCodeEntity) {
        Long relId = ioSplitCodeEntity.getRelId();
        UdiRelevanceEntity relevanceEntity = udiRelevanceService.getById(relId);
        int n = IntUtil.value(relevanceEntity.getUnpackUseTime());
        // 获取当前时间
        Calendar calendar = Calendar.getInstance();
        Date unpackTime = calendar.getTime();
        // 加上n小时
        calendar.add(Calendar.HOUR_OF_DAY, n);
        // 转换为Date对象
        Date unpackExpireTime = calendar.getTime();
        ioSplitCodeEntity.setUnpackTime(unpackTime);
        ioSplitCodeEntity.setUnpackExpireTime(unpackExpireTime);
    }

    /**
     * 扫描拆包过期进行处理损耗出库
     */
    public void asyncUnpackExpireTask() {
        LambdaQueryWrapper<IoSplitCodeEntity> lqw = new LambdaQueryWrapper<>();
        Date now = new Date();
        lqw.lt(IoSplitCodeEntity::getUnpackExpireTime, now);

        List<IoSplitCodeEntity> ioSplitCodeEntities = splitCodeMapper.selectList(lqw);
        if (CollUtil.isNotEmpty(ioSplitCodeEntities)) {
            //进行损耗出库
            IoSplitDesOrder collectOrder;
            List<IoSplitDesOrderDetail> splitDesOrderDetails = new ArrayList<>();
            List<Long> removeByIds = new ArrayList<>();
            collectOrder = IoSplitDesOrder.builder()
                    .id(IdUtil.getSnowflakeNextId())
                    .billNo(gennerOrderUtils.createWdOrderNo(new OrderNoTypeBean(Constant.SPLIT_DES_ORDER, "yyyyMMdd")))
                    .busType(null)
                    .workPlaceCode(null)
                    .createTime(new Date())
                    .billTime(new Date())
                    .remark(null)
                    .status(2)
                    .createUser("1")
                    .updateTime(new Date())
                    .updateUser("1")
                    .build();
            splitDesOrderService.save(collectOrder);

            ioSplitCodeEntities.forEach(splitCodeEntity -> {
                //损耗详细表
                IoSplitDesOrderDetail splitDesOrderDetail = IoSplitDesOrderDetail.builder()
                        .id(IdUtil.getSnowflakeNextId())
                        .workPlaceCode(collectOrder.getWorkPlaceCode())
                        .orderIdFk(collectOrder.getBillNo())
                        .relId(splitCodeEntity.getRelId())
                        .batchNo(splitCodeEntity.getBatchNo())
                        .produceDate(splitCodeEntity.getProduceDate())
                        .expireDate(splitCodeEntity.getExpireDate())
                        .supId(splitCodeEntity.getSupId())
                        .count(splitCodeEntity.getRemainCount())
                        .reCount(splitCodeEntity.getRemainCount())
                        .createTime(new Date())
                        .updateTime(new Date())
                        .remark("").build();
                splitDesOrderDetails.add(splitDesOrderDetail);
                removeByIds.add(splitCodeEntity.getId());
            });

            if (removeByIds.size() > 0) {
                this.removeByIds(removeByIds);
            }
            if (splitDesOrderDetails.size() > 0) {
                splitDesOrderDetailService.saveBatch(splitDesOrderDetails);
            }
        }
    }
}