package com.glxp.api.service.inout;

import org.springframework.beans.BeanUtils;
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.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
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.constant.ConstantType;
import com.glxp.api.dao.inout.IoOrderDetailCodeDao;
import com.glxp.api.entity.auth.InvWarehouseEntity;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.BasicCorpEntity;
import com.glxp.api.entity.basic.UdiEntity;
import com.glxp.api.entity.basic.UdiRlSupEntity;
import com.glxp.api.entity.inout.*;
import com.glxp.api.entity.inv.InvPreInProductDetailEntity;
import com.glxp.api.entity.inv.InvProductDetailEntity;
import com.glxp.api.entity.system.SystemParamConfigEntity;
import com.glxp.api.req.basic.FilterCompanyProductRelevanceRequest;
import com.glxp.api.entity.inout.PdaCodeEntity;
import com.glxp.api.req.inout.PdaPostOrderRequest;
import com.glxp.api.req.inout.PostOrderRequest;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.res.inv.InvPlaceDetailResponse;
import com.glxp.api.service.auth.InvWarehouseService;
import com.glxp.api.service.basic.BasicCorpService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.basic.UdiRelevanceService;
import com.glxp.api.service.basic.UdiRlSupService;
import com.glxp.api.service.inv.InvPreProductDetailService;
import com.glxp.api.service.inv.InvPreinProductDetailService;
import com.glxp.api.service.inv.InvProductDetailService;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.util.*;
import com.glxp.api.util.udi.FilterUdiUtils;
import com.glxp.api.util.udi.UdiCalCountUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import static com.glxp.api.constant.ConstantStatus.ORDER_STATUS_CHECK_PROCESS;

@Service
public class IoAddInoutService {

    @Resource
    private IBasicBussinessTypeService basicBussinessTypeService;
    @Resource
    private IoOrderService orderService;
    @Resource
    GennerOrderUtils gennerOrderUtils;
    @Resource
    IoCodeService codeService;
    @Resource
    IoCodeTempService codeTempService;
    @Resource
    UdiRlSupService udiRlSupService;
    @Resource
    IoOrderDetailCodeService orderDetailCodeService;
    @Resource
    UdiRelevanceService udiRelevanceService;
    @Resource
    InvProductDetailService invProductDetailService;
    @Resource
    BasicCorpService basicCorpService;
    @Resource
    IoCheckInoutService ioCheckInoutService;
    @Resource
    SystemParamConfigService systemParamConfigService;
    @Resource
    IoOrderDetailBizService orderDetailBizService;
    @Resource
    private IoOrderDetailCodeDao orderDetailCodeDao;
    @Resource
    InvWarehouseService invWarehouseService;

    //新增扫码单据处理
    public void dealProcess(IoOrderEntity orderEntity) {

        orderEntity.setErrMsg("正在处理！");
        orderEntity.setStatus(ConstantStatus.ORDER_STATUS_PROCESSING);
        orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
        orderEntity.setUpdateTime(new Date());
        orderService.update(orderEntity);

        List<IoOrderEntity> orderEntities = orderService.isExitRepeat(orderEntity.getCorpOrderId(), orderEntity.getBillNo());

        if (CollUtil.isNotEmpty(orderEntities)) {
            orderEntity.setErrMsg("单据重复上传");
            orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
            orderEntity.setUpdateTime(new Date());
            orderService.update(orderEntity);
            return;
        }

        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
        if (bussinessTypeEntity == null) {
            orderEntity.setErrMsg("单据类型不存在");
            orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
            orderEntity.setUpdateTime(new Date());
            orderService.update(orderEntity);
            return;
        }
        if (StrUtil.isEmpty(orderEntity.getFromCorp()) && StrUtil.isEmpty(orderEntity.getFromInvCode())) {
            orderEntity.setErrMsg("未选择往来单位");
            orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
            orderEntity.setUpdateTime(new Date());
            orderService.update(orderEntity);
            return;
        } else if (StrUtil.isNotEmpty(orderEntity.getFromCorp())) {
            if (bussinessTypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_INPUT && bussinessTypeEntity.isGenUnit()) {

                BasicCorpEntity basicCorpEntity = basicCorpService.selectByName(orderEntity.getFromCorp());
                if (basicCorpEntity == null) {
                    basicCorpEntity = new BasicCorpEntity();
                    basicCorpEntity.setErpId(CustomUtil.getUnitId());
                    basicCorpEntity.setCorpType(ConstantStatus.CORP_SICK);
                    basicCorpEntity.setOutType(ConstantStatus.CORP_SICK_SICK);
                    basicCorpEntity.setName(orderEntity.getFromCorp());
                    basicCorpEntity.setId(IdUtil.getSnowflakeNextId());
                    basicCorpService.insert(basicCorpEntity);
                }
                orderEntity.setFromCorp(basicCorpEntity.getErpId());
                orderEntity.setUpdateTime(new Date());
                orderService.update(orderEntity);

            }
        }


        if (StrUtil.isEmpty(orderEntity.getInvCode())) {
            orderEntity.setErrMsg("未选择当前仓库信息");
            orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
            orderEntity.setUpdateTime(new Date());
            orderService.update(orderEntity);
            return;
        }


        List<IoCodeTempEntity> filterList = codeTempService.findByOrderId(orderEntity.getBillNo());
        List<IoCodeTempEntity> insertList = new ArrayList<>();

        for (int j = 0; j < filterList.size(); j++) {
            IoCodeTempEntity warehouseEntity = filterList.get(j);
            String result = checkOrderRepeatCode(warehouseEntity, filterList);
            if (result == null) {
                insertList.add(warehouseEntity);
            } else {
                orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
                orderEntity.setUpdateTime(new Date());
                orderEntity.setErrMsg(result);
                orderService.update(orderEntity);
                insertList.clear();
                return;
            }

            if (bussinessTypeEntity.isCodeFillCheck()) {
                //三期校验
                String checkOriginMsg = checkOriginCode(warehouseEntity);
                if (StrUtil.isNotEmpty(checkOriginMsg)) {
                    orderEntity.setErrMsg(checkOriginMsg);
                    orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
                    orderEntity.setUpdateTime(new Date());
                    orderService.update(orderEntity);
                    insertList.clear();
                    return;
                }
            }


            //产品是否已维护已关联
            if ((warehouseEntity.getRelId() == null)) {
                orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
                orderEntity.setUpdateTime(new Date());
                orderEntity.setErrMsg("udi码：" + warehouseEntity.getCode() + "上传时对照数据丢失！");
                orderService.update(orderEntity);
                return;
            }

            //产品是否指定供应商
            if (StrUtil.isEmpty(warehouseEntity.getSupId())) {
                orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
                orderEntity.setUpdateTime(new Date());
                orderEntity.setErrMsg("udi码：" + warehouseEntity.getCode() + "未指定供应商！");
                orderService.update(orderEntity);
                return;
            }

            //校验是否是当前供应商
            if (bussinessTypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_OUT) {
                UdiRlSupEntity udiRlSupEntity = udiRlSupService.findByUdiRlIdUnitFk(warehouseEntity.getRelId() + "", orderEntity.getFromCorp());
                if (udiRlSupEntity == null) {
                    orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
                    orderEntity.setUpdateTime(new Date());
                    orderEntity.setErrMsg("udi码：" + warehouseEntity.getCode() + "当前供应商不存在此配送产品");
                    orderService.update(orderEntity);
                    return;
                }
            }

            //产品是否可以以使用单元入库
            UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectGroupById(warehouseEntity.getRelId());
            if (udiRelevanceResponse == null) {
                orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
                orderEntity.setUpdateTime(new Date());
                orderEntity.setErrMsg("udi码：" + warehouseEntity.getCode() + "该产品信息未维护");
                orderService.update(orderEntity);
                return;
            } else if (!udiRelevanceResponse.getUseDy() && udiRelevanceResponse.getDiType() == ConstantStatus.DITYPE_SYDY) {

                orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
                orderEntity.setUpdateTime(new Date());
                orderEntity.setErrMsg("udi码：" + warehouseEntity.getCode() + "该产品不允许以使用单元入库");
                orderService.update(orderEntity);
                return;
            }

        }

        if (CollUtil.isNotEmpty(insertList)) {
            //生成扫码单据详情
            if (!orderDetailCodeService.isExit(orderEntity.getBillNo())) {
                for (IoCodeTempEntity codeTempEntity : insertList) {
                    genOrderDetailCode(orderEntity, codeTempEntity);
                }
            }
            orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
            orderEntity.setUpdateTime(new Date());
            orderEntity.setErrMsg("");
            orderService.update(orderEntity);
        } else {
            orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
            orderEntity.setUpdateTime(new Date());
            orderEntity.setErrMsg("未添加UDI码");
            orderService.update(orderEntity);
        }

    }


    //新增业务单据处理
    public void dealBusProcess(IoOrderEntity orderEntity, BasicBussinessTypeEntity bussinessTypeEntity) {

        orderEntity.setErrMsg("正在处理！");
        orderEntity.setStatus(ConstantStatus.ORDER_STATUS_PROCESSING);
        orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
        orderEntity.setUpdateTime(new Date());
        orderService.update(orderEntity);


        List<IoOrderEntity> orderEntities = orderService.isExitRepeat(orderEntity.getCorpOrderId(), orderEntity.getBillNo());
        if (CollUtil.isNotEmpty(orderEntities)) {
            orderEntity.setErrMsg("单据重复上传");
            orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
            orderEntity.setUpdateTime(new Date());
            orderService.update(orderEntity);
            return;
        }


        if (StrUtil.isEmpty(orderEntity.getFromCorp()) && StrUtil.isEmpty(orderEntity.getFromInvCode())) {
            orderEntity.setErrMsg("未选择往来单位");
            orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
            orderEntity.setUpdateTime(new Date());
            orderService.update(orderEntity);
            return;
        }

        if (StrUtil.isEmpty(orderEntity.getInvCode())) {
            orderEntity.setErrMsg("未选择当前仓库信息");
            orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
            orderEntity.setUpdateTime(new Date());
            orderService.update(orderEntity);
            return;
        }


        String errMsg = "";
        List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(orderEntity.getBillNo());
        if (CollUtil.isNotEmpty(orderDetailBizEntities)) {
            for (IoOrderDetailBizEntity orderDetailBizEntity : orderDetailBizEntities) {
                if (StrUtil.isEmpty(orderDetailBizEntity.getSupId())) {
                    errMsg = errMsg + orderDetailBizEntity.getCoName() + "未绑定供应商;";
                }
                if (orderDetailBizEntity.getBindRlFk() == null) {
                    errMsg = errMsg + orderDetailBizEntity.getCoName() + "未绑定耗材字典编码;";
                }
            }
        }

        if (StrUtil.isNotEmpty(errMsg)) {
            orderEntity.setErrMsg(errMsg);
            orderEntity.setStatus(ConstantStatus.ORDER_STATS_ERROR);
            orderEntity.setUpdateTime(new Date());
            orderService.update(orderEntity);
            return;
        }
        orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
        orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
        orderEntity.setUpdateTime(new Date());
        orderService.update(orderEntity);
        return;

    }


    //生成扫码单据详情
    public List<IoOrderDetailCodeEntity> genOrderDetailCode(IoOrderEntity orderEntity, IoCodeTempEntity codeTempEntity) {

        List<IoOrderDetailCodeEntity> ioOrderDetailCodeEntities = orderDetailCodeDao.selectList(new QueryWrapper<IoOrderDetailCodeEntity>().select("id", "count", "reCount", "bindRlFk", "batchNo").eq("orderIdFk", orderEntity.getBillNo()));
        UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectSupGroupById(codeTempEntity.getRelId(), codeTempEntity.getSupId());
        if (CollUtil.isEmpty(ioOrderDetailCodeEntities)) {
            orderDetailCodeService.insert(buildEntity(orderEntity, codeTempEntity, udiRelevanceResponse));
        } else {
            boolean isUpdate = false;
            for (IoOrderDetailCodeEntity orderDetailCodeEntity : ioOrderDetailCodeEntities) {
                if (orderDetailCodeEntity.getBindRlFk().longValue() == udiRelevanceResponse.getId().longValue()
                        &&
                        StrUtil.trimToEmpty(orderDetailCodeEntity.getBatchNo()).equals(StrUtil.trimToEmpty(codeTempEntity.getBatchNo()))) {
                    orderDetailCodeEntity.setCount(orderDetailCodeEntity.getCount() + codeTempEntity.getMyCount());
                    orderDetailCodeEntity.setReCount(orderDetailCodeEntity.getReCount() + codeTempEntity.getMyReCount());

                    UpdateWrapper<IoOrderDetailCodeEntity> updateWrapper = new UpdateWrapper<>();
                    updateWrapper.set("count", orderDetailCodeEntity.getCount()).set("reCount", orderDetailCodeEntity.getReCount());
                    orderDetailCodeEntity.setUpdateTime(new Date());
                    orderDetailCodeDao.updateCount(orderDetailCodeEntity);
                    isUpdate = true;
                    break;
                }
            }
            if (!isUpdate) {
                orderDetailCodeService.insert(buildEntity(orderEntity, codeTempEntity, udiRelevanceResponse));
            }
        }
        return ioOrderDetailCodeEntities;
    }

    //平衡补单
    public BaseResponse supplementOrder(String orderId) {

        IoOrderEntity order = orderService.findByBillNo(orderId);
        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(order.getAction());
        if (StrUtil.isBlank(bussinessTypeEntity.getSupplementOrderType())) {
            return ResultVOUtils.error(500, "此类型单据不可补单");
        }
        IoOrderEntity supplementOrder = new IoOrderEntity();
        BeanUtils.copyProperties(order, supplementOrder);

        //生成补单单号,互填单号
        String supplementOrderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
        supplementOrder.setSupplementNo(orderId);
        order.setSupplementNo(supplementOrderNo);
        supplementOrder.setBillNo(supplementOrderNo);
        supplementOrder.setCorpOrderId(CustomUtil.getId() + "x");

        //修改状态
        SystemParamConfigEntity systemParamConfigEntity = systemParamConfigService.selectByParamKey("additional_auto_submit");
        if ("1".equals(systemParamConfigEntity.getParamValue())) {
            supplementOrder.setStatus(ConstantStatus.ORDER_STATUS_PROCESS);        //设置状态为补录单据
        } else {
            supplementOrder.setStatus(ConstantStatus.ORDER_STATUS_ADDITIONAL);        //设置状态为补录单据
        }

        //交换往来信息
        supplementOrder.setFromDeptCode(order.getDeptCode());
        supplementOrder.setFromInvCode(order.getInvCode());
        supplementOrder.setInvCode(order.getFromInvCode());
        supplementOrder.setDeptCode(order.getFromDeptCode());
        supplementOrder.setFromType(ConstantStatus.FROM_PEACE_CHANGE);

        //设置往来信息
        BasicBussinessTypeEntity supplementType = basicBussinessTypeService.findByAction(bussinessTypeEntity.getSupplementOrderType());
        supplementOrder.setMainAction(supplementType.getMainAction());
        supplementOrder.setAction(supplementType.getAction());
        supplementOrder.setBusType(supplementType.getBusType());
        //复制码表
        List<IoCodeEntity> codes = codeService.findByOrderId(orderId);
        List<IoCodeTempEntity> supplementCodes = new ArrayList<>();
        codes.forEach(
                code -> {
                    IoCodeTempEntity supplementCode = new IoCodeTempEntity();
                    BeanUtils.copyProperties(code, supplementCode);
                    supplementCode.setId(null);
                    supplementCode.setInvCode(order.getFromInvCode());
                    supplementCode.setDeptCode(order.getFromDeptCode());
                    supplementCode.setOrderId(supplementOrderNo);
                    supplementCode.setAction(supplementType.getAction());
                    supplementCode.setWarehouseCode(null);
                    supplementCode.setPreInSpaceCode(null);
                    supplementCode.setPreSpaceCode(null);
                    supplementCode.setMainAction(supplementType.getMainAction());
                    supplementCodes.add(supplementCode);

                }
        );

        //更新数据
        orderService.insertOrder(supplementOrder);
        orderService.update(order);
        codeTempService.insertBatch(supplementCodes);
        dealProcess(supplementOrder);
        if (!ioCheckInoutService.checkManual(supplementOrder.getBillNo())) {
            ioCheckInoutService.check(supplementOrder.getBillNo());
        }
        return ResultVOUtils.success();
    }


    /**
     * 手持终端-----新增出入库单据
     *
     * @param pdaPostOrderRequest
     * @return
     */
    public BaseResponse creatOrderByPda(PdaPostOrderRequest pdaPostOrderRequest) {

        IoOrderEntity orderEntity = pdaPostOrderRequest.getOrderEntity();
        IoOrderEntity tempEntity = orderService.findByBillNo(orderEntity.getBillNo());
        if (tempEntity != null) {
            return ResultVOUtils.error(500, "单据已存在，请勿重复提交");
        }
        tempEntity = orderService.findByCorpOrderId(orderEntity.getCorpOrderId());
        if (tempEntity != null) {
            return ResultVOUtils.error(500, "单据已存在，请勿重复提交");
        }

        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());

        BaseResponse baseResponse = checkInv(bussinessTypeEntity, pdaPostOrderRequest.getOrderDetailBizEntities(), orderEntity, pdaPostOrderRequest.getCodeTempEntities());
        if (baseResponse != null)
            return baseResponse;

        String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
        orderEntity.setBillNo(orderNo);
        orderService.insertOrder(orderEntity);

        if (CollUtil.isNotEmpty(pdaPostOrderRequest.getCodeTempEntities())) {
            for (IoCodeTempEntity codeTempEntity : pdaPostOrderRequest.getCodeTempEntities()) {
                codeTempEntity.setOrderId(orderNo);
            }
            codeTempService.insertBatch(pdaPostOrderRequest.getCodeTempEntities());
        }

        dealProcess(orderEntity);
        if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
            ioCheckInoutService.check(orderEntity.getBillNo());
        }
        return ResultVOUtils.success("单据上传成功！");

    }

    /**
     * 手持终端-----待配货(无三期，有三期）单据提交
     *
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public BaseResponse waitOrderByPda(PdaPostOrderRequest pdaPostOrderRequest) {
        IoOrderEntity orderEntity = pdaPostOrderRequest.getOrderEntity();
        IoOrderEntity temp = orderService.findByBillNo(orderEntity.getBillNo());
        BaseResponse tempResponse = checkSubmitEnable(temp);
        if (tempResponse != null)
            return tempResponse;

        List<IoOrderDetailBizEntity> orderDetailBizEntities = pdaPostOrderRequest.getOrderDetailBizEntities();
        List<IoCodeTempEntity> codeTempEntities = pdaPostOrderRequest.getCodeTempEntities();

        orderDetailBizService.deleteByOrderId(orderEntity.getBillNo());
        orderDetailCodeService.deleteByOrderId(orderEntity.getBillNo());
        codeTempService.deleteByBillNo(orderEntity.getBillNo());
        if (CollUtil.isNotEmpty(orderDetailBizEntities)) {
            orderDetailBizEntities.forEach(orderDetailBizEntity -> {
                orderDetailBizService.insert(orderDetailBizEntity);
                IoOrderDetailCodeEntity orderDetailCodeEntity = new IoOrderDetailCodeEntity();
                BeanUtils.copyProperties(orderDetailBizEntity, orderDetailCodeEntity);
                orderDetailCodeEntity.setReCount(orderDetailBizEntity.getScanCount());
                orderDetailCodeEntity.setCount(orderDetailBizEntity.getCodeCount());
                orderDetailCodeService.insert(orderDetailCodeEntity);
            });
        }
        if (CollUtil.isNotEmpty(codeTempEntities)) {
            codeTempEntities.forEach(codeTempEntity -> {
                codeTempService.insert(codeTempEntity);
            });
        }
        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
        if (ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
            List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(orderEntity.getBillNo());
            if (CollUtil.isNotEmpty(orderDetailBizEntities)) {
                if (bussinessTypeEntity.getCheckWebNew() == 1) {
                    String errMsg = ioCheckInoutService.bizOrderCheck(orderDetailBizEntities, orderDetailCodeEntities);
                    if (StrUtil.isNotEmpty(errMsg)) {
                        return ResultVOUtils.error(500, errMsg);
                    }
                    errMsg = ioCheckInoutService.codeOrderCheck(orderDetailCodeEntities, orderDetailBizEntities);
                    if (StrUtil.isNotEmpty(errMsg)) {
                        return ResultVOUtils.error(500, errMsg);
                    }
//                    saveOrderWeb(addOrderRequest);
                    orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
                    orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
                    orderService.update(orderEntity);
                    ioCheckInoutService.check(orderEntity.getBillNo());
                } else {
                    String errMsg = ioCheckInoutService.bizNoPiCheck(orderDetailBizEntities, orderEntity);
                    if (StrUtil.isNotEmpty(errMsg)) {
                        return ResultVOUtils.error(500, errMsg);
                    }
                    orderDetailBizService.deleteByOrderId(orderEntity.getBillNo());
                    for (IoOrderDetailCodeEntity orderDetailCodeEntity : orderDetailCodeEntities) {
                        IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
                        BeanUtils.copyProperties(orderDetailCodeEntity, orderDetailBizEntity);
                        orderDetailBizEntity.setId(null);
                        orderDetailBizEntity.setCount(IntUtil.value(orderDetailCodeEntity.getReCount()));
                        ioCheckInoutService.getSomeBiz(orderDetailBizEntities, orderDetailBizEntity);
                        orderDetailBizService.insert(orderDetailBizEntity);
                    }
//                    saveOrderWeb(addOrderRequest);
                    orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
                    orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
                    orderService.update(orderEntity);
                    dealProcess(orderEntity);
                    ioCheckInoutService.check(orderEntity.getBillNo());
                }


            } else {
                return ResultVOUtils.error(500, "单据校验提交失败,请先录入业务单据！");
            }
        } else {
            orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
            dealProcess(orderEntity);
            ioCheckInoutService.check(orderEntity.getBillNo());
            return ResultVOUtils.success("提交成功！");
        }
        return ResultVOUtils.success("提交成功！");
    }


    /**
     * 手持终端------扫码结果提交
     *
     * @return
     */
    @Transactional(rollbackFor = Exception.class)
    public BaseResponse checkCodeResultByPda(Integer checkWebNewType, PdaPostOrderRequest pdaPostOrderRequest) {

        IoOrderEntity orderEntity = pdaPostOrderRequest.getOrderEntity();
        IoOrderEntity temp = orderService.findByBillNo(orderEntity.getBillNo());
        BaseResponse tempResponse = checkSubmitEnable(temp);
        if (tempResponse != null)
            return tempResponse;

        List<IoOrderDetailBizEntity> orderDetailBizEntities = pdaPostOrderRequest.getOrderDetailBizEntities();
        List<IoCodeTempEntity> codeTempEntities = pdaPostOrderRequest.getCodeTempEntities();

        orderDetailBizService.deleteByOrderId(orderEntity.getBillNo());
        orderDetailCodeService.deleteByOrderId(orderEntity.getBillNo());
        codeTempService.deleteByBillNo(orderEntity.getBillNo());
        if (CollUtil.isNotEmpty(orderDetailBizEntities)) {
            orderDetailBizEntities.forEach(orderDetailBizEntity -> {
                orderDetailBizService.insert(orderDetailBizEntity);
                IoOrderDetailCodeEntity orderDetailCodeEntity = new IoOrderDetailCodeEntity();
                BeanUtils.copyProperties(orderDetailBizEntity, orderDetailCodeEntity);
                orderDetailCodeEntity.setReCount(orderDetailBizEntity.getScanCount());
                orderDetailCodeEntity.setCount(orderDetailBizEntity.getCodeCount());
                orderDetailCodeService.insert(orderDetailCodeEntity);
            });
        }
        if (CollUtil.isNotEmpty(codeTempEntities)) {
            codeTempEntities.forEach(codeTempEntity -> {
                codeTempService.insert(codeTempEntity);
            });
        }
        orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
        orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
        orderService.update(orderEntity);
        ioCheckInoutService.checkCodeResult(orderEntity.getBillNo());
//        if (checkWebNewType == 0) {
//
//        } else {
//            dealProcess(orderEntity);
//            ioCheckInoutService.checkRightResult(orderEntity.getBillNo());
//        }
        return ResultVOUtils.success("提交成功！");
    }


    //校验条码关联供应商
    public String checkExitSup(Long relId) {
        FilterCompanyProductRelevanceRequest filterCompanyProductRelevanceRequest = new FilterCompanyProductRelevanceRequest();
        filterCompanyProductRelevanceRequest.setUdiRlIdFk(relId + "");
        List<UdiRlSupEntity> companyProductRelevanceEntities = udiRlSupService.filterCompanyProductRelevance(filterCompanyProductRelevanceRequest);
        if (companyProductRelevanceEntities != null && companyProductRelevanceEntities.size() == 1) {
            UdiRlSupEntity udiRlSupEntity = companyProductRelevanceEntities.get(0);
            return udiRlSupEntity.getUnitFk();
        } else if (companyProductRelevanceEntities != null && companyProductRelevanceEntities.size() > 1) {
            String unitFk = companyProductRelevanceEntities.get(0).getUnitFk();
            boolean isMuti = false;
            for (UdiRlSupEntity udiRlSupEntity : companyProductRelevanceEntities) {
                if (!unitFk.equals(udiRlSupEntity.getUnitFk())) {
                    isMuti = true;
                    break;
                }
            }
            if (isMuti)
                return "MUTI";      //绑定多个供应商
            else
                return unitFk;
        }
        return null;
    }

    public String checkInvExitSup(IoCodeEntity codeEnttity) {
        String supId = checkNorInv(codeEnttity);
        if (supId == null) {
            return checkPreInv(codeEnttity);
        }
        return supId;
    }

    //查普通库存  todo
    public String checkNorInv(IoCodeEntity codeEnttity) {

//        FilterInvWarehouseRequest filterInvWarehouseRequest = new FilterInvWarehouseRequest();
//        filterInvWarehouseRequest.setLevel(1);
//        filterInvWarehouseRequest.setAdvanceType(false);
//        List<InvWarehouseEntity> invWarehouseEntities = invWarehouseService.filterInvWarehouse(filterInvWarehouseRequest);
//        List<String> codes = new ArrayList<>();
//        if (!invWarehouseEntities.isEmpty()) {
//            for (InvWarehouseEntity invWarehouseEntity : invWarehouseEntities) {
//                codes.add(invWarehouseEntity.getCode());
//            }
//        }
//        FilterInvProductRequest filterInvProductDetailRequest = new FilterInvProductRequest();
//        filterInvProductDetailRequest.setRelIdFk(codeEnttity.getRelId());
//        filterInvProductDetailRequest.setBatchNo(codeEnttity.getBatchNo());
//        filterInvProductDetailRequest.setInvCodes(codes);
//        List<InvProductEntity> invProductEntities = invProductService.filterInvProduct(filterInvProductDetailRequest);
//        if (invProductEntities.size() > 0) {
//            String supId = invProductEntities.get(0).getSupId();
//            int count = 0;
//            for (InvProductEntity invProductEntity : invProductEntities) {
//                if (!supId.equals(invProductEntity.getSupId())) {
//                    return null;
//                }
//                count = count + (invProductEntity.getInCount() - invProductEntity.getOutCount());
//            }
//            if (count > 0)
//                return supId;
//        }

        return null;
    }

    //查寄售库存  todo
    public String checkPreInv(IoCodeEntity codeEnttity) {
//        FilterInvWarehouseRequest filterInvWarehouseRequest = new FilterInvWarehouseRequest();
//        filterInvWarehouseRequest.setLevel(1);
//        filterInvWarehouseRequest.setAdvanceType(true);
//        List<InvWarehouseEntity> invWarehouseEntities = invWarehouseService.filterInvWarehouse(filterInvWarehouseRequest);
//        List<String> codes = new ArrayList<>();
//        if (!invWarehouseEntities.isEmpty()) {
//            for (InvWarehouseEntity invWarehouseEntity : invWarehouseEntities) {
//                codes.add(invWarehouseEntity.getCode());
//            }
//        }
//        FilterInvProductRequest filterInvProductDetailRequest = new FilterInvProductRequest();
//        filterInvProductDetailRequest.setRelIdFk(codeEnttity.getRelId());
//        filterInvProductDetailRequest.setBatchNo(codeEnttity.getBatchNo());
//        filterInvProductDetailRequest.setInvCodes(codes);
//        List<InvProductEntity> invProductEntities = invPreProductService.filterInvProduct(filterInvProductDetailRequest);
//        if (invProductEntities.size() > 0) {
//            String supId = invProductEntities.get(0).getSupId();
//            int count = 0;
//            for (InvProductEntity invProductEntity : invProductEntities) {
//                if (!supId.equals(invProductEntity.getSupId())) {
//                    return null;
//                }
//                count = count + (invProductEntity.getInCount() - invProductEntity.getOutCount());
//            }
//            if (count > 0)
//                return supId;
//        }

        return null;
    }

    //查询本单是否有重复条码
    public String checkOrderRepeatCode(IoCodeTempEntity codeEntity, List<IoCodeTempEntity> filterList) {
        int count = 0;
        if (filterList != null) {
            for (IoCodeTempEntity temp : filterList) {
                if (temp.getCode().equals(codeEntity.getCode()) && StrUtil.trimToEmpty(temp.getSerialNo()).equals(StrUtil.trimToEmpty(codeEntity.getSerialNo()))) {
                    count = count + 1;
                }
            }
        }
        if (count > 1) {
            return codeEntity.getCode() + "条码重复";
        } else
            return null;
    }


    public String checkOriginCode(IoCodeTempEntity warehouseEntity) {

        UdiEntity udiEntity = FilterUdiUtils.getUdi(warehouseEntity.getCode());
        //校验条码的完整性
        String errMsg = "";
        UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByNameCode(udiEntity.getUdi());
        if (udiRelevanceResponse == null) {
            return "耗材字典不存在此产品";
        }
        InvProductDetailEntity invProductDetailEntity = invProductDetailService.sortFindByCode(warehouseEntity.getCode());
        if (invProductDetailEntity != null) {
            if (StrUtil.isEmpty(warehouseEntity.getBatchNo())) {
                warehouseEntity.setBatchNo(invProductDetailEntity.getBatchNo());
            }
            if (StrUtil.isEmpty(warehouseEntity.getProduceDate())) {
                warehouseEntity.setProduceDate(invProductDetailEntity.getProduceDate());
            }
            if (StrUtil.isEmpty(warehouseEntity.getExpireDate())) {
                warehouseEntity.setExpireDate(invProductDetailEntity.getExpireDate());
            }
        }

        if (StrUtil.isEmpty(warehouseEntity.getBatchNo()) && !udiRelevanceResponse.getAllowNoBatch()) {
            errMsg = errMsg + ",批次号";
        }
        if (StrUtil.isEmpty(warehouseEntity.getProduceDate()) && !udiRelevanceResponse.getAllowNoProduct()) {
            errMsg = errMsg + ",生产日期";
        }
        if (StrUtil.isEmpty(warehouseEntity.getExpireDate()) && !udiRelevanceResponse.getAllowNoExpire()) {
            errMsg = errMsg + ",失效日期";
        }

        if (StrUtil.isNotEmpty(errMsg)) {
            return "UDI码" + warehouseEntity.getCode() + "产品三期缺失请补齐" + errMsg.substring(1) + "";
        }
        return null;
    }


    IoOrderDetailCodeEntity buildEntity(IoOrderEntity orderEntity, IoCodeTempEntity codeTempEntity, UdiRelevanceResponse udiRelevanceResponse) {
        IoOrderDetailCodeEntity ioOrderDetailCodeEntity = new IoOrderDetailCodeEntity();
        ioOrderDetailCodeEntity.setOrderIdFk(orderEntity.getBillNo());
        ioOrderDetailCodeEntity.setBindRlFk(udiRelevanceResponse.getId());
        ioOrderDetailCodeEntity.setUuidFk(udiRelevanceResponse.getUuid());
        ioOrderDetailCodeEntity.setBatchNo(codeTempEntity.getBatchNo());
        ioOrderDetailCodeEntity.setNameCode(codeTempEntity.getNameCode());
        ioOrderDetailCodeEntity.setProductDate(codeTempEntity.getProduceDate());
        ioOrderDetailCodeEntity.setExpireDate(codeTempEntity.getExpireDate());
        ioOrderDetailCodeEntity.setCoName(udiRelevanceResponse.getCpmctymc());
        ioOrderDetailCodeEntity.setCertCode(udiRelevanceResponse.getZczbhhzbapzbh());
        ioOrderDetailCodeEntity.setYlqxzcrbarmc(udiRelevanceResponse.getYlqxzcrbarmc());
        ioOrderDetailCodeEntity.setManufacturer(udiRelevanceResponse.getManufactory());
        ioOrderDetailCodeEntity.setMeasname(udiRelevanceResponse.getMeasname());
        ioOrderDetailCodeEntity.setSpec(udiRelevanceResponse.getGgxh());
        ioOrderDetailCodeEntity.setSupId(codeTempEntity.getSupId());
        ioOrderDetailCodeEntity.setPrice(udiRelevanceResponse.getPrice());
        ioOrderDetailCodeEntity.setCount(codeTempEntity.getCount());
        ioOrderDetailCodeEntity.setReCount(codeTempEntity.getMyReCount());
        ioOrderDetailCodeEntity.setUpdateTime(new Date());
        return ioOrderDetailCodeEntity;
    }


    /**
     * 临床出库时更新往来单位信息
     */
    public String updateCorp(BasicBussinessTypeEntity bussinessTypeEntity, String fromCorp) {
        BasicCorpEntity basicCorpEntity;
        //要是特殊往来信息没有就创建
        if (bussinessTypeEntity.getCorpType() == ConstantStatus.CORP_TYPE_INPUT && bussinessTypeEntity.isGenUnit()) {
            basicCorpEntity = basicCorpService.selectByName(fromCorp);
            if (basicCorpEntity == null) {
                basicCorpEntity = new BasicCorpEntity();
                basicCorpEntity.setErpId(CustomUtil.getUnitId());
                basicCorpEntity.setCorpType(ConstantStatus.CORP_SICK);
                basicCorpEntity.setOutType(ConstantStatus.CORP_SICK_SICK);
                basicCorpEntity.setName(fromCorp);
                basicCorpEntity.setId(IdUtil.getSnowflakeNextId());
                basicCorpService.insert(basicCorpEntity);
            }
            return basicCorpEntity.getErpId();

        } else {
            return fromCorp;
        }
    }

    public BaseResponse checkSubmitEnable(IoOrderEntity orderEntity) {
        if (orderEntity == null) {
            return ResultVOUtils.error(500, "提交失败，请先添加物资！");
        }
        if (orderEntity.getStatus() == ORDER_STATUS_CHECK_PROCESS || orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_PROCESS
                || orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_PROCESSING) {
            return ResultVOUtils.error(500, "提交失败，单据正在处理，请稍后刷新查看！");
        }
        if (orderEntity.getStatus() != 1 && orderEntity.getStatus() != 3 && orderEntity.getStatus() != 4 && orderEntity.getStatus() != 6) {
            return ResultVOUtils.error(500, "提交失败，单据已提交，请稍后刷新查看！");
        }
        return null;
    }

    @Resource
    InvPreProductDetailService invPreProductDetailService;
    @Resource
    InvPreinProductDetailService invPreinProductDetailService;

    /**
     * 手持终端上传校验库存
     */
    public BaseResponse checkInv(BasicBussinessTypeEntity bussinessTypeEntity, List<IoOrderDetailBizEntity> orderDetailBizEntities, IoOrderEntity orderEntity, List<IoCodeTempEntity> codeTempEntities) {
        if (bussinessTypeEntity.isScanPreIn()) {    //校验预验收库存

            InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByOne(ConstantStatus.ACTION_TYPE_PREIN);
            for (IoCodeTempEntity codeTempEntity : codeTempEntities) {
                int count = 0;
                if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_NULL) {
                    if (StrUtil.isNotEmpty(codeTempEntity.getSerialNo())) {
                        count = invPreinProductDetailService.vailStockCountByCode(null, invWarehouseEntity.getCode(), null, codeTempEntity.getCode());
                    } else
                        count = invPreinProductDetailService.vailStockCount(codeTempEntity.getRelId(), codeTempEntity.getBatchNo(), codeTempEntity.getSupId(), null, invWarehouseEntity.getCode(), null);
                } else if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_SET) {
                    if (StrUtil.isNotEmpty(codeTempEntity.getSerialNo())) {
                        count = invPreinProductDetailService.vailStockCountByCode(null, invWarehouseEntity.getCode(), codeTempEntity.getPreInSpaceCode(), codeTempEntity.getCode());
                    } else
                        count = invPreinProductDetailService.vailStockCount(codeTempEntity.getRelId(), codeTempEntity.getBatchNo(), codeTempEntity.getSupId(), null, invWarehouseEntity.getCode(), codeTempEntity.getPreInSpaceCode());
                }
                if (count < IntUtil.value(codeTempEntity.getReCount())) {
                    return ResultVOUtils.error(500, "UDI码：" + codeTempEntity.getCode() + "预验收库存数量不足！");
                }
            }
        } else if (bussinessTypeEntity.isAdvancePreIn()) {  //校验寄售库存

            InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByOne(ConstantStatus.ACTION_TYPE_ADVANCE);
            for (IoOrderDetailBizEntity orderDetailCodeEntity : orderDetailBizEntities) {
                int count = 0;
                if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_NULL) {
                    count = invPreProductDetailService.vailStockCount(orderDetailCodeEntity.getBindRlFk(), orderDetailCodeEntity.getBatchNo(), orderDetailCodeEntity.getSupId(), null, invWarehouseEntity.getCode(), null);
                } else if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_SET) {
                    count = invPreProductDetailService.vailStockCount(orderDetailCodeEntity.getBindRlFk(), orderDetailCodeEntity.getBatchNo(), orderDetailCodeEntity.getSupId(), null, invWarehouseEntity.getCode(), orderEntity.getPreCurSpaceCode());
                }
                if (count < orderDetailCodeEntity.getScanCount()) {
                    return ResultVOUtils.error(500, "提交失败，" + orderDetailCodeEntity.getCoName() + "库存数量不足！");
                }
            }

        } else {        //校验普通库存
            if (bussinessTypeEntity.isVailInv() && bussinessTypeEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
                for (IoOrderDetailBizEntity orderDetailCodeEntity : orderDetailBizEntities) {
                    int count = 0;
                    if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_NULL) {
                        count = invProductDetailService.vailStockCount(orderDetailCodeEntity.getBindRlFk(), orderDetailCodeEntity.getBatchNo(), orderDetailCodeEntity.getSupId(), orderEntity.getDeptCode(), orderEntity.getInvCode(), null);
                    } else if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_SET) {
                        count = invProductDetailService.vailStockCount(orderDetailCodeEntity.getBindRlFk(), orderDetailCodeEntity.getBatchNo(), orderDetailCodeEntity.getSupId(), orderEntity.getDeptCode(), orderEntity.getInvCode(), orderEntity.getCurSpaceCode());
                    }
                    if (count < orderDetailCodeEntity.getScanCount()) {
                        return ResultVOUtils.error(500, "提交失败，" + orderDetailCodeEntity.getCoName() + "库存数量不足！");
                    }
                }
            }
        }

        return null;
    }

}