package com.glxp.api.service.inout;

import cn.hutool.core.collection.CollUtil;
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.extension.plugins.pagination.Page;
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.dao.inout.IoCodeTempDao;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.UdiEntity;
import com.glxp.api.entity.basic.UdiProductEntity;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderDetailCodeEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.req.inout.AddEnterCodeRequest;
import com.glxp.api.req.inout.FilterCodeRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.res.collect.RelCodeDetailResponse;
import com.glxp.api.res.inout.AddEnterCodeResponse;
import com.glxp.api.res.inout.IoCodeResponse;
import com.glxp.api.res.inout.IoCodeTempResponse;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.basic.UdiProductService;
import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.collect.RelCodeDetailService;
import com.glxp.api.service.inout.impl.IoCodeService;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.util.BeanCopyUtils;
import com.glxp.api.util.IntUtil;
import com.glxp.api.util.page.PageQuery;
import com.glxp.api.util.page.TableDataInfo;
import com.glxp.api.util.udi.FilterUdiUtils;
import com.glxp.api.util.udi.UdiCalCountUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.HashMap;

@Service
@Transactional(rollbackFor = Exception.class)
@Slf4j
public class IoCodeTempService {

    @Resource
    IoCodeTempDao ioCodeTempDao;


    public IoCodeTempEntity selectById(Integer id) {
        return ioCodeTempDao.selectById(id);
    }


    public int insert(IoCodeTempEntity codeEnttity) {
        codeEnttity.setId(null);
        return ioCodeTempDao.insert(codeEnttity);
    }


    public int deleteById(Integer id) {
        return ioCodeTempDao.deleteById(id);
    }


    public boolean insertBatch(List<IoCodeTempEntity> codeEnttities) {
        return ioCodeTempDao.insertBatch(codeEnttities);
    }


    public List<IoCodeTempEntity> findByOrderId(String billNo) {
        return ioCodeTempDao.selectList(new QueryWrapper<IoCodeTempEntity>().eq("orderId", billNo));
    }


    public List<IoCodeResponse> findJoinByOrderId(String billNo) {
        if (StrUtil.isEmpty(billNo))
            return null;
        FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
        filterCodeRequest.setOrderId(billNo);
        return ioCodeTempDao.filterJoinProduct(filterCodeRequest);
    }

    public List<IoCodeResponse> findJoinByBizId(Long bizId) {
        if (bizId == null)
            return null;
        FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
        filterCodeRequest.setBizId(bizId);
        return ioCodeTempDao.filterJoinProduct(filterCodeRequest);
    }


    public int updateById(IoCodeTempEntity codeEnttity) {
        return ioCodeTempDao.updateById(codeEnttity);
    }


    public int updateByOrderId(IoCodeTempEntity codeTempEntity) {
        return ioCodeTempDao.update(codeTempEntity, new QueryWrapper<IoCodeTempEntity>().eq("orderId", codeTempEntity.getOrderId()));
    }


    public IoCodeTempEntity findByUnique(String orderId, String code) {
        List<IoCodeTempEntity> codeTempEntities = ioCodeTempDao.selectList(new QueryWrapper<IoCodeTempEntity>().eq("orderId", orderId).eq("code", code));
        if (CollUtil.isNotEmpty(codeTempEntities)) {
            IoCodeTempEntity codeTempEntity = codeTempEntities.get(0);
            if (codeTempEntities.size() > 1) {
                for (int i = 1; i < codeTempEntities.size(); i++) {
                    codeTempEntity.setCount(codeTempEntity.getCount() + codeTempEntities.get(i).getCount());
                    codeTempEntity.setReCount(codeTempEntity.getReCount() + codeTempEntities.get(i).getReCount());
                }
            }

            return codeTempEntity;

        }

        return null;
    }


    public TableDataInfo<IoCodeTempEntity> findByOrderId(FilterCodeRequest filterCodeRequest) {
        PageQuery pageQuery = new PageQuery();
        BeanCopyUtils.copy(filterCodeRequest, pageQuery);
        Page<IoCodeTempEntity> page = ioCodeTempDao.selectPage(pageQuery.build(), new QueryWrapper<IoCodeTempEntity>().eq("orderId", filterCodeRequest.getOrderId()));
        return TableDataInfo.build(page);
    }


    public int deleteByBillNo(String orderId) {
        return ioCodeTempDao.delete(new QueryWrapper<IoCodeTempEntity>().eq("orderId", orderId));
    }


    public List<IoCodeTempResponse> findCodeList(FilterCodeRequest filterCodeRequest) {
        if (null != filterCodeRequest && null != filterCodeRequest.getPage() && null != filterCodeRequest.getLimit()) {
            PageHelper.offsetPage((filterCodeRequest.getPage() - 1) * filterCodeRequest.getLimit(), filterCodeRequest.getLimit());
        }
        return ioCodeTempDao.selectCodeList(filterCodeRequest);
    }


    public boolean isExit(String orderId) {
        return ioCodeTempDao.exists(new QueryWrapper<IoCodeTempEntity>().eq("orderId", orderId));
    }


    public Integer selectExitCount(String orderId, String bacthNo, Long relId, String supId) {
        FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
        filterCodeRequest.setOrderId(orderId);
        filterCodeRequest.setBatchNo(bacthNo);
        filterCodeRequest.setRelId(relId + "");
        filterCodeRequest.setSupId(supId);
        return ioCodeTempDao.selectExitCount(filterCodeRequest);
    }


    public Integer selectExitCount(String orderId, String code) {
        FilterCodeRequest filterCodeRequest = new FilterCodeRequest();
        filterCodeRequest.setOrderId(orderId);
        filterCodeRequest.setCode(code);
        return ioCodeTempDao.selectExitCount(filterCodeRequest);
    }


    public Boolean checkTempCode(IoCodeTempEntity ioCodeTempEntity) {

        QueryWrapper<IoCodeTempEntity> ew = new QueryWrapper<>();
        ew.eq("code", ioCodeTempEntity.getCode());
        ew.eq("corpOrderId", ioCodeTempEntity.getCorpOrderId());
        ew.eq("batchNo", ioCodeTempEntity.getBatchNo());
        ew.eq("produceDate", ioCodeTempEntity.getProduceDate());
        ew.eq("expireDate", ioCodeTempEntity.getExpireDate());
        ew.eq("serialNo", ioCodeTempEntity.getSerialNo());
        Long count = ioCodeTempDao.selectCount(ew);
        if (count > 0) {
            return false;
        }
        return true;
    }


    public IoCodeTempEntity selectByCode(String code, String batchNo, String action) {
        QueryWrapper<IoCodeTempEntity> ew = new QueryWrapper<>();
        ew.eq("code", code);
        ew.eq(StrUtil.isNotEmpty(batchNo), "batchNo", batchNo);
        ew.eq(StrUtil.isNotEmpty(action), "action", action);
        return ioCodeTempDao.selectOne(ew);
    }


    public List<IoCodeTempEntity> selectByCodes(List<String> codeList, String orderId) {
        QueryWrapper<IoCodeTempEntity> ew = new QueryWrapper<>();
        ew.eq("orderId", orderId);
        ew.in("code", codeList);
        return ioCodeTempDao.selectList(ew);
    }


    @Resource
    private IoOrderService orderService;
    @Resource
    private IBasicBussinessTypeService basicBussinessTypeService;
    @Resource
    UdiRelevanceService udiRelevanceService;
    @Resource
    UdiCalCountUtil udiCalCountUtil;
    @Resource
    IoOrderDetailCodeService ioOrderDetailCodeService;
    @Resource
    IoOrderDetailBizService orderDetailBizService;


    public Boolean removeCodeById(IoCodeTempEntity codeTempEntity) {

        IoOrderEntity orderEntity = orderService.findByBillNo(codeTempEntity.getOrderId());
        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
        UdiRelevanceResponse udiRelevanceResponses = udiRelevanceService.selectByNameCode(codeTempEntity.getNameCode());

        if (codeTempEntity.getMyCount() > 1) {
            codeTempEntity.setCount(codeTempEntity.getMyCount() - 1);
            if (bussinessTypeEntity.isUse()) {
                codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getUseActCount(udiRelevanceResponses));
            } else {
                codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getCirActCount(udiRelevanceResponses));
            }
            updateById(codeTempEntity);
        } else {
            deleteById(codeTempEntity.getId());
        }

        //更新扫码详情
        IoOrderDetailCodeEntity orderDetailCodeEntity = ioOrderDetailCodeService.findByUnique(orderEntity.getBillNo(), codeTempEntity.getRelId(), codeTempEntity.getBatchNo(), codeTempEntity.getPrice());
        if (orderDetailCodeEntity != null) {
            //扫码数量-1
            int orderCount = IntUtil.value(orderDetailCodeEntity.getCount());
            int orderReCount = IntUtil.value(orderDetailCodeEntity.getReCount());
            if (orderCount > 1) {
                orderDetailCodeEntity.setCount(orderCount - 1);


                if (bussinessTypeEntity.isUse()) {
                    orderDetailCodeEntity.setReCount(orderReCount - udiCalCountUtil.getUseActCount(udiRelevanceResponses));
//                    codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getUseActCount(udiRelevanceResponses);
                } else {
                    orderDetailCodeEntity.setReCount(orderReCount - udiCalCountUtil.getCirActCount(udiRelevanceResponses));
//                    codeTempEntity.setReCount(codeTempEntity.getMyReCount() - udiCalCountUtil.getCirActCount(udiRelevanceResponses);
                }

                ioOrderDetailCodeService.update(orderDetailCodeEntity);
            } else {
                ioOrderDetailCodeService.deleteById(orderDetailCodeEntity.getId());
            }
        }


        boolean r1 = orderDetailBizService.isExit(orderEntity.getBillNo());
        boolean r2 = ioOrderDetailCodeService.isExit(orderEntity.getBillNo());
        if (!r1 && !r2) {
            if (StrUtil.isNotEmpty(orderDetailCodeEntity.getOrderIdFk()))
                orderService.deleteByBillNo(orderDetailCodeEntity.getOrderIdFk());
        }

        orderEntity.setUpdateTime(new Date());
        orderService.update(orderEntity);
        return true;
    }


    @Resource
    RelCodeDetailService relCodeDetailService;

    public boolean ieExitRel(String code, String orderId) {
        boolean ret = false;
        RelCodeDetailResponse relCodeDetail = relCodeDetailService.findByCode(code);
        if (relCodeDetail != null) {
            //判断是否存在关联关系：1.先判断当前单号是否存在父码，若存在则表示存在关联关系重复扫码
            if (StrUtil.isNotEmpty(relCodeDetail.getParentCode())) {
                ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getCode, relCodeDetail.getParentCode()));
                if (!ret) {
                    relCodeDetail = relCodeDetailService.findByCode(relCodeDetail.getParentCode());
                    ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getCode, relCodeDetail.getParentCode()));
                }
            }
            if (ret)
                return true;
            //若父码不存在，判断当前单号是否存在当前码的子码，若存在则表示存在关联关系重复扫码
            ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getParentCode, code));
            if (!ret) {
                ret = ioCodeTempDao.exists(new LambdaQueryWrapper<IoCodeTempEntity>().eq(IoCodeTempEntity::getOrderId, orderId).eq(IoCodeTempEntity::getGrantPaCode, code));
            }
        }
        return ret;
    }


    @Resource
    IoCodeService ioCodeService;

    public BaseResponse findCodes(FilterCodeRequest filterCodeRequest) {
        List<IoCodeResponse> ioCodeResponses = ioCodeService.filterList(filterCodeRequest);
        PageInfo<IoCodeResponse> pageInfo = new PageInfo<>(ioCodeResponses);
        PageSimpleResponse<IoCodeResponse> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setTotal(pageInfo.getTotal());
        pageSimpleResponse.setList(pageInfo.getList());
        return ResultVOUtils.success(pageSimpleResponse);
    }

    public Integer selectMaxGroupNumber() {
        return ioCodeTempDao.selectMaxGroupNumber();
    }

    public IoCodeTempEntity selectOone(FilterCodeRequest filterCodeRequest) {
        return ioCodeTempDao.selectOne(new LambdaQueryWrapper<IoCodeTempEntity>()
                .eq(IoCodeTempEntity::getCode,filterCodeRequest.getCode())
                .eq(IoCodeTempEntity::getQueueCode,filterCodeRequest.getQueueCode())
                        .eq(IoCodeTempEntity::getAction,"SC72197936495755")
                );
    }

    public List<IoCodeTempEntity> selectListByGroupNumber(Integer groupNumber) {
        return ioCodeTempDao.selectList(new LambdaQueryWrapper<IoCodeTempEntity>()
                .eq(IoCodeTempEntity::getGroupNumber,groupNumber)
        );
    }

    public BaseResponse checkRedundant(AddEnterCodeRequest addEnterCodeRequest,String newCode,String originCode) {
        String tempOriginCode = addEnterCodeRequest.getOriginCode();
        if (tempOriginCode.endsWith("\u001D")) {
            tempOriginCode = tempOriginCode.replace("\u001D", "");
        }
        UdiEntity originUdiEntity = FilterUdiUtils.getUdi(tempOriginCode);
        if (StrUtil.isNotEmpty(newCode)) {
            if (newCode.startsWith("10")) {
                if (StrUtil.isNotEmpty(originUdiEntity.getBatchNo())) {
                    BaseResponse baseResponse = ResultVOUtils.error(501, "批次号重复添加");
                    baseResponse.setData(originCode);
                    return baseResponse;
                } else {
                    String msg = checkNewCode(originUdiEntity, newCode);
                    if (msg != null) {
                        BaseResponse baseResponse = ResultVOUtils.error(501, msg);
                        baseResponse.setData(originCode);
                        return baseResponse;
                    }
                }
            } else if (newCode.startsWith("17")) {
                if (StrUtil.isNotEmpty(originUdiEntity.getExpireDate())) {
                    BaseResponse baseResponse = ResultVOUtils.error(501, "失效日期重复添加");
                    baseResponse.setData(originCode);
                    return baseResponse;
                } else {
                    String msg = checkNewCode(originUdiEntity, newCode);
                    if (msg != null) {
                        BaseResponse baseResponse = ResultVOUtils.error(501, msg);
                        baseResponse.setData(originCode);
                        return baseResponse;
                    }
                }
            } else if (newCode.startsWith("11")) {
                if (StrUtil.isNotEmpty(originUdiEntity.getProduceDate())) {
                    BaseResponse baseResponse = ResultVOUtils.error(501, "生产日期重复添加");
                    baseResponse.setData(originCode);
                    return baseResponse;
                } else {
                    String msg = checkNewCode(originUdiEntity, newCode);
                    if (msg != null) {
                        BaseResponse baseResponse = ResultVOUtils.error(501, msg);
                        baseResponse.setData(originCode);
                        return baseResponse;
                    }
                }
            } else if (newCode.startsWith("21")) {
                if (StrUtil.isNotEmpty(originUdiEntity.getSerialNo())) {
                    BaseResponse baseResponse = ResultVOUtils.error(501, "序列号重复添加");
                    baseResponse.setData(originCode);
                    return baseResponse;
                } else {
                    String msg = checkNewCode(originUdiEntity, newCode);
                    if (msg != null) {
                        BaseResponse baseResponse = ResultVOUtils.error(501, msg);
                        baseResponse.setData(originCode);
                        return baseResponse;
                    }
                }
            } else {
                BaseResponse baseResponse = ResultVOUtils.error(501, "格式错误");
                baseResponse.setData(originCode);
                return baseResponse;
            }
        }
        return ResultVOUtils.success();
    }

    public String checkNewCode(UdiEntity originEnity, String newCode) {
        UdiEntity newEntity = FilterUdiUtils.getUdi(originEnity.getUdi() + newCode);
        if (newEntity == null || originEnity == null) {
            return null;
        }
        if (StrUtil.isNotEmpty(originEnity.getBatchNo()) && StrUtil.isNotEmpty(newEntity.getBatchNo())) {
            return "批次号重复添加！";
        }
        if (StrUtil.isNotEmpty(originEnity.getProduceDate()) && StrUtil.isNotEmpty(newEntity.getProduceDate())) {
            return "生产日期重复添加！";
        }
        if (StrUtil.isNotEmpty(originEnity.getExpireDate()) && StrUtil.isNotEmpty(newEntity.getExpireDate())) {
            return "失效日期重复添加！";
        }
        if (StrUtil.isNotEmpty(originEnity.getSerialNo()) && StrUtil.isNotEmpty(newEntity.getSerialNo())) {
            return "序列号重复添加！";
        }
        return null;
    }


    @Autowired
    private SystemParamConfigService systemParamConfigService;

    @Autowired
    UdiProductService udiProductService;
    public BaseResponse checkFormat(String code,String originCode) {
        // TODO: 2024/9/13 首次无单进入的时候报错提示，不需要执行校验
        UdiEntity udiEntity = FilterUdiUtils.getUdi(code);
        if (udiEntity == null) {
            String sptmtodi = systemParamConfigService.selectValueByParamKey(Constant.SPTM_TO_DI);
            if (sptmtodi.equals("1")) {
                if (code.length() == 13) {
                    UdiProductEntity udiProductEntity = udiProductService.findBySptm(code);
                    if (udiProductEntity != null) {
                        BaseResponse baseResponse = ResultVOUtils.error(508, "追溯码格式错误");
                        baseResponse.setData(udiProductEntity);
                        return baseResponse;
                    }
                }
            }
            BaseResponse baseResponse = ResultVOUtils.error(501, "追溯码格式错误");
            baseResponse.setData(originCode);
            return baseResponse;
        }
        return ResultVOUtils.success(udiEntity);
    }

    public BaseResponse checkCode(UdiEntity udiEntity,String code,UdiRelevanceResponse checkUdi,String newCode) {
        boolean checkSuccess = true;
        String lostMsg = "";
        //校验条码完整性
        if ("是".equals(checkUdi.getScbssfbhph()) && StrUtil.isEmpty(udiEntity.getBatchNo())) {
            checkSuccess = false;
            lostMsg = lostMsg + ",批次号";
        }
        if ("是".equals(checkUdi.getScbssfbhscrq()) && StrUtil.isEmpty(udiEntity.getProduceDate())) {
            checkSuccess = false;
            lostMsg = lostMsg + ",生产日期";
        }

        if ("是".equals(checkUdi.getScbssfbhsxrq()) && StrUtil.isEmpty(udiEntity.getExpireDate())) {
            checkSuccess = false;
            lostMsg = lostMsg + ",失效日期";
        }
        if (checkUdi.getAllowNoSerial() != null && !checkUdi.getAllowNoSerial() && StrUtil.isEmpty(udiEntity.getSerialNo())
        ) {
            checkSuccess = false;
            lostMsg = lostMsg + ",序列号";
        }
        if (StrUtil.isNotEmpty(udiEntity.getSerialNo()) && udiEntity.getSerialNo().length() > 20) {
            return ResultVOUtils.error(504, "序列号超出20位！");
        }
        if (StrUtil.isNotEmpty(udiEntity.getBatchNo()) && udiEntity.getBatchNo().length() > 20) {
            return ResultVOUtils.error(504, "批次号超出20位！");
        }
        if (StrUtil.isEmpty(udiEntity.getSerialNo()) && StrUtil.isEmpty(udiEntity.getBatchNo())) {
            checkSuccess = false;
        }
        if (checkSuccess) {
            if (code.endsWith("\u001D")) {
                code = code.substring(0, code.length() - "\u001D".length());
            }
            udiEntity.setCode(code);
            AddEnterCodeResponse addEnterCodeResponse = setAddEnterCodeResponse(udiEntity, checkUdi);
            return ResultVOUtils.success(addEnterCodeResponse);
        } else {
            if (newCode.startsWith("21") || (StrUtil.isNotEmpty(udiEntity.getSerialNo()) && newCode.contains("21" + udiEntity.getSerialNo()))) {
                if (StrUtil.isEmpty(lostMsg)) {
                    lostMsg = ",";
                }
                BaseResponse baseResponse = ResultVOUtils.error(503, "条码完整性错误,缺少" + lostMsg.substring(1) + "是否继续添加？");
                udiEntity.setCode(code);
                AddEnterCodeResponse addEnterCodeResponse = setAddEnterCodeResponse(udiEntity, checkUdi);
                baseResponse.setData(addEnterCodeResponse);
                return baseResponse;
            }
        }
        BaseResponse baseResponse = ResultVOUtils.error(502, "校验未完成,缺少" + lostMsg.substring(1));
        udiEntity.setCode(code);
        AddEnterCodeResponse addEnterCodeResponse = setAddEnterCodeResponse(udiEntity, checkUdi);
        baseResponse.setData(addEnterCodeResponse);
        return baseResponse;
    }

    public AddEnterCodeResponse setAddEnterCodeResponse(UdiEntity udiEntity, UdiRelevanceResponse checkUdi) {
        AddEnterCodeResponse addEnterCodeResponse = new AddEnterCodeResponse();
        BeanUtils.copyProperties(udiEntity, addEnterCodeResponse);
        addEnterCodeResponse.setBzgg(checkUdi.getBzgg());
        addEnterCodeResponse.setCpmctymc(checkUdi.getCpmctymc());
        addEnterCodeResponse.setPrepnSpec(checkUdi.getPrepnSpec());
        addEnterCodeResponse.setPrepnUnit(checkUdi.getPrepnUnit());
        addEnterCodeResponse.setPackUnit(checkUdi.getPackUnit());
        addEnterCodeResponse.setGgxh(checkUdi.getGgxh());
        return addEnterCodeResponse;
    }

    /**
     * 批量插入码信息
     * @param entities 码信息实体列表
     * @return 是否成功
     */
    public boolean batchInsert(List<IoCodeTempEntity> entities) {
        if (CollUtil.isEmpty(entities)) {
            return true;
        }
        
        // 分批插入，每批最多500条
        int batchSize = 500;
        int totalSize = entities.size();
        boolean result = true;
        
        for (int i = 0; i < totalSize; i += batchSize) {
            int end = Math.min(i + batchSize, totalSize);
            List<IoCodeTempEntity> batch = entities.subList(i, end);
            result = result && ioCodeTempDao.insertBatch(batch);
        }
        
        return result;
    }
    
    /**
     * 批量更新码信息
     * @param entities 码信息实体列表
     * @return 受影响的行数
     */
    public int batchUpdate(List<IoCodeTempEntity> entities) {
        if (CollUtil.isEmpty(entities)) {
            return 0;
        }
        
        int updatedRows = 0;
        for (IoCodeTempEntity entity : entities) {
            updatedRows += ioCodeTempDao.updateById(entity);
        }
        
        return updatedRows;
    }
    
    /**
     * 批量检查码是否存在
     * @param codes 码列表
     * @param orderId 订单ID
     * @return 存在的码实体映射
     */
    public Map<String, IoCodeTempEntity> batchCheckCodesExistence(List<String> codes, String orderId) {
        if (CollUtil.isEmpty(codes) || StrUtil.isEmpty(orderId)) {
            return new HashMap<>();
        }
        
        List<IoCodeTempEntity> existingEntities = selectByCodes(codes, orderId);
        if (CollUtil.isEmpty(existingEntities)) {
            return new HashMap<>();
        }
        
        Map<String, IoCodeTempEntity> codeToEntityMap = new HashMap<>();
        for (IoCodeTempEntity entity : existingEntities) {
            codeToEntityMap.put(entity.getCode(), entity);
        }
        
        return codeToEntityMap;
    }
}