package com.zy.common.web;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.core.common.BaseRes;
import com.core.common.Cools;
import com.core.common.R;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.EmptyPlateOutParam;
import com.zy.asrs.entity.result.FindLocNoAttributeVo;
import com.zy.asrs.mapper.LocMastMapper;
import com.zy.asrs.service.*;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.StartupDto;
import com.zy.common.service.CommonService;
import com.zy.common.web.param.CanningLineInLocParam;
import com.zy.common.web.param.SearchLocParam;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.Map;

/**
 * Created by vincent on 2020/10/30
 */
@Slf4j
@RestController
@RequestMapping("/rpc")
public class WcsController {

    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private BasDevpService basDevpService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private WaitPakinService waitPakinService;
    @Autowired
    private  LocDetlService locDetlService;
    @Autowired
    private RowLastnoService rowLastnoService;
    @Autowired
    private WorkService workService;

    @Resource
    private LocMastMapper locMastMapper;

    @Resource
    private MatService matService;

    @Resource
    private ConfigService configService;

    @PostMapping("/pakin/loc/v1")
    @ResponseBody
    @Transactional
    public synchronized R getLocNo(@RequestBody SearchLocParam param) {
        log.info("收到WCS入库接口请求====>>入参:{}", param);
        if (Cools.isEmpty(param.getIoType())) {
            return R.error("入出库类型不能为空");
        }
        if (Cools.isEmpty(param.getSourceStaNo())) {
            return R.error("源站编号不能为空");
        }
        WaitPakin waitPakin = null;
        if (param.getIoType() == 1) {
            // 先创建入库通知档
            waitPakin = comb(param.getBarcode(),param.getBucketType(),param.getBucketCount());
//            if (Cools.isEmpty(param.getBarcode())) {
//                return R.error("条码不能为空");
//            }
//            waitPakins = waitPakinService.selectList(new EntityWrapper<WaitPakin>().eq("zpallet", param.getBarcode()));
//            if (Cools.isEmpty(waitPakins)) {
//                WrkMast wrkMast = wrkMastService.selectByBarcode(param.getBarcode());
//                if (wrkMast != null && wrkMast.getIoType() == 103) {
//                    return R.parse(CodeRes.PICK_600);
//                }
//                return R.parse(CodeRes.NO_COMB_700);
//            }
//            int countLoc = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet",param.getBarcode()));
//            int countWrk = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("zpallet",param.getBarcode()));
//            if (countLoc > 0 || countWrk > 0) {
//                return R.error(CodeRes.EXIST_500);
//            }
        }
        if (Cools.isEmpty(param.getLocType1())){
            return R.error("高低检测信号不能为空");
        }

        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(param.getSourceStaNo(), true);
        sourceStaNo.setLocType1(param.getLocType1());
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);

        StartupDto dto = null;

        if(param.getIoType() == 1) {
            Map<Integer, String> wantBucketFlag = param.getWantBucketFlag();
            if(!wantBucketFlag.isEmpty()) {
                if(waitPakin == null) {
                    return R.error("入库通知档为空");
                } else {
                    dto = startupFullPutStore(param,waitPakin); // 直供罐装线任务
                    if (dto != null) {
                        log.info("WCS入库直供罐装线接口返参:{},托盘码:{}", dto, param.getBarcode());
                        return R.ok().add(dto);
                    }
                }
            }
        }

        switch (param.getIoType()) {
            case 1://满托盘入库
                assert waitPakin != null;
                dto = startupFullPutStore(param.getSourceStaNo(), param.getBarcode(), locTypeDto, waitPakin, param.getLocArea(),param.isTailSupportFlag());
                break;
            case 10://空托盘入库
                dto = emptyPlateIn(param.getSourceStaNo(), locTypeDto, param.getBarcode(), 1);
                break;
            default:
                break;
        }
        log.info("WCS入库接口返参:{},托盘码:{}", dto, param.getBarcode());
        return R.ok().add(dto);
    }

    // 罐装完成入库
    @PostMapping("/pakin/CanningLine/loc/v1")
    @ResponseBody
    @Transactional
    public synchronized R getLocNo(@RequestBody CanningLineInLocParam param) {
        log.info("收到WCS罐装入库接口请求====>>入参:{}", param);
        if (Cools.isEmpty(param.getWrkNo())) {
            return R.error("工作号不能为空");
        }
        if (Cools.isEmpty(param.getSourceStaNo())) {
            return R.error("源站编号不能为空");
        }

        // 根据任务号查询任务
        WrkMast wrkMast1 = wrkMastService.selectById(param.getWrkNo());
        // 根据任务号查询任务明细
        WrkDetl wrkDetl1 = wrkDetlService.selectOne(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkMast1.getWrkNo()));
        // 分配库位
        StartupDto dto = commonService.getLocNoNew(1, param.getSourceStaNo(), null, 1);

        // 创建新任务
        int workNo = dto.getWorkNo();
        Date now = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(2L); // 工作状态：生成入库ID
        wrkMast.setIoType(1); // 入出库状态：1.入库
        wrkMast.setIoPri(13D); // 优先级
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
        wrkMast.setLocNo(dto.getLocNo());
        wrkMast.setBarcode(wrkMast1.getBarcode()); // 托盘码
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setCtnType(wrkMast1.getCtnType()); // 尾托标识
        wrkMast.setPdcType(wrkMast1.getPdcType()); // 空桶类型
        wrkMast.setAppeTime(now);
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
        }

        // 生成工作档明细
        // todo 入成品桶库的物料 这里先根据空桶类型指定成品桶物料
        String matnr;
        if(wrkMast1.getPdcType().equals("208L")) {
            matnr = "YJ2025011814414206";
        } else {
            matnr = "YJ2025011814412359";
        }
        Mat mat = matService.selectByMatnr(matnr);
        WrkDetl wrkDetl = new WrkDetl();
        wrkDetl.sync(mat);
        wrkDetl.setWrkNo(workNo);
        wrkDetl.setAnfme(wrkDetl1.getAnfme());
        wrkDetl.setZpallet(wrkMast1.getBarcode());
        wrkDetl.setIoTime(now);
        wrkDetl.setAppeTime(now);
        if (!wrkDetlService.insert(wrkDetl)) {
            throw new CoolException("保存工作明细失败");
        }

        // 完成旧任务(直供罐装线任务手动完成,出库任务任务号消失会自动完成)
        if (wrkMast1.getIoType() == 2) {
            wrkMast1.setWrkSts(4L);
            wrkMast1.setModiTime(now);
            wrkMastService.updateById(wrkMast1);
        }

        // 更新源站点信息
        BasDevp basDevp = basDevpService.selectById(param.getSourceStaNo());
        basDevp.setWrkNo(workNo);
        basDevp.setModiTime(now);
        if (!basDevpService.updateById(basDevp)) {
            throw new CoolException("更新源站失败");
        }

        // 更新目标库位状态
        LocMast locMast = locMastService.selectById(dto.getLocNo());
        if (locMast.getLocSts().equals("O")) {
            locMast.setLocSts("S"); // S.入库预约
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("改变库位状态失败");
            }
        } else {
            log.error(dto.getLocNo() + "目标库位已被占用");
            throw new CoolException(dto.getLocNo() + "目标库位已被占用");
        }

        log.info("WCS罐装入库接口返参:{},托盘码:{}", dto, wrkMast1.getBarcode());
        return R.ok(dto);
    }

    @Transactional(propagation = Propagation.REQUIRED)
    public WaitPakin comb(String barcode, String matnr,int bucketCount) {
        if (Cools.isEmpty(barcode, matnr,bucketCount)) {
            throw new CoolException(BaseRes.PARAM);
        }

        // 判断是否有相同条码的数据
        if (waitPakinService.selectCount(new EntityWrapper<WaitPakin>().
                eq("zpallet", barcode).eq("io_status", "N")) > 0) {
            throw new CoolException(barcode + "数据正在进行入库");
        }

        if(barcode.length()!=8){
            throw new CoolException("条码长度不是8位===>>" + barcode);
        }

        int countLoc = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("zpallet",barcode));
        int countWrk = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("zpallet",barcode));
        int countwait = waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("zpallet",barcode));
        if (countLoc > 0 || countWrk > 0 || countwait > 0) {
            throw new CoolException("组托档/工作档/库存条码数据已存在===>>" + barcode);
        }

        Date now = new Date();

        // 无单组托
//        if (Cools.isEmpty(param.getOrderNo())) {

            // 生成入库通知档
//            List<DetlDto> detlDtos = new ArrayList<>();
//            param.getCombMats().forEach(elem -> {
//                DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(),elem.getBrand(),elem.getStandby1(),elem.getStandby2(),elem.getStandby3(),
//                        elem.getBoxType1(),elem.getBoxType2(),elem.getBoxType3(),  elem.getAnfme());
//                if (DetlDto.has(detlDtos, detlDto)) {
//                    DetlDto one = DetlDto.findDto(detlDtos, detlDto);
//                    assert one != null;
//                    one.setAnfme(one.getAnfme() + detlDto.getAnfme());
//                } else {
//                    detlDtos.add(detlDto);
//                }
//            });


//            for (DetlDto detlDto : detlDtos) {
                Mat mat = matService.selectByMatnr(matnr);
                if (Cools.isEmpty(mat)) {
                    throw new CoolException(matnr + "商品档案不存在");
                }
//                // 判断空桶类型
//                Config config = configService.selectConfigByCode("EmptyBucketType");
//                if (config == null) {
//                    log.info("配置入库空桶类型为空");
//                    throw new CoolException("配置入库空桶类型为空");
//                }
//                String[] split = config.getValue().split("=");
//                String bucketType = split[0];
//                Integer sum = Integer.valueOf(split[1]);
//                int count = bucketType.equals("IBC") ? 1 : 4;
                WaitPakin waitPakin = new WaitPakin();
                waitPakin.sync(mat);
//                waitPakin.setBatch(detlDto.getBatch());
                waitPakin.setZpallet(barcode);   // 托盘码
                waitPakin.setIoStatus("N");     // 入出状态
                waitPakin.setAnfme((double) bucketCount);  // 数量
                waitPakin.setStatus("Y");    // 状态
                waitPakin.setAppeUser(29L);
                waitPakin.setAppeTime(now);
                waitPakin.setModiUser(29L);
                waitPakin.setModiTime(now);
                if (!waitPakinService.insert(waitPakin)) {
                    throw new CoolException("保存入库通知档失败");
                }
                return waitPakin;
//            }
            // 关联组托
//        } else {
////            Order order = orderService.selectByNo(param.getOrderNo());
//            Order order = OrderInAndOutUtil.selectByNo(Boolean.TRUE, param.getOrderNo());
//            if (Cools.isEmpty(order) || order.getSettle() > 2) {
//                throw new CoolException("单据编号已过期");
//            }
//            // 生成入库通知档
//            List<DetlDto> detlDtos = new ArrayList<>();
//            param.getCombMats().forEach(elem -> {
//
//                // 订单明细数量校验
////                OrderDetl orderDetl = orderDetlService.selectItem(order.getId(), elem.getMatnr(), elem.getBatch());
//                OrderDetl orderDetl = OrderInAndOutUtil.selectItem(Boolean.TRUE, order.getId(), elem.getMatnr(), elem.getBatch(),elem.getBrand(),elem.getStandby1(),elem.getStandby2(),elem.getStandby3(),
//                        elem.getBoxType1(),elem.getBoxType2(),elem.getBoxType3());
//                if (elem.getAnfme() > orderDetl.getEnableQty()) {
//                    throw new CoolException(orderDetl.getMatnr() + "入库数量不合法");
//                }
//                // 修改订单作业数量
////                if (!orderDetlService.increaseWorkQty(order.getId(), elem.getMatnr(), elem.getBatch(), elem.getAnfme())) {
////                    throw new CoolException("修改单据作业数量失败");
////                }
//                OrderInAndOutUtil.increaseWorkQty(Boolean.TRUE,order.getId(), elem.getMatnr(), elem.getBatch(),elem.getBrand(),elem.getStandby1(),elem.getStandby2(),elem.getStandby3(),
//                        elem.getBoxType1(),elem.getBoxType2(),elem.getBoxType3(), elem.getAnfme());
//                DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(),elem.getBrand(),elem.getStandby1(),elem.getStandby2(),elem.getStandby3(),
//                        elem.getBoxType1(),elem.getBoxType2(),elem.getBoxType3(),  elem.getAnfme());
//                if (DetlDto.has(detlDtos, detlDto)) {
//                    DetlDto one = DetlDto.findDto(detlDtos, detlDto);
//                    assert one != null;
//                    one.setAnfme(one.getAnfme() + detlDto.getAnfme());
//                } else {
//                    detlDtos.add(detlDto);
//                }
//            });
//            for (DetlDto detlDto : detlDtos) {
//                Mat mat = matService.selectByMatnr(detlDto.getMatnr());
//                if (Cools.isEmpty(mat)) {
//                    throw new CoolException(detlDto.getMatnr() + "商品档案不存在");
//                }
//                WaitPakin waitPakin = new WaitPakin();
//                waitPakin.sync(mat);
//                waitPakin.setOrderNo(order.getOrderNo());   // 单据编号
//                waitPakin.setBatch(detlDto.getBatch());     // 序列码
//                waitPakin.setZpallet(param.getBarcode());   // 托盘码
//                waitPakin.setIoStatus("N");     // 入出状态
//                waitPakin.setAnfme(detlDto.getAnfme());  // 数量
//                waitPakin.setStatus("Y");    // 状态
//                waitPakin.setAppeUser(userId);
//                waitPakin.setAppeTime(now);
//                waitPakin.setModiUser(userId);
//                waitPakin.setModiTime(now);
//                if (!waitPakinService.insert(waitPakin)) {
//                    throw new CoolException("保存入库通知档失败");
//                }
//            }
////            orderService.updateSettle(order.getId(), 2L, userId);
//            OrderInAndOutUtil.updateOrder(Boolean.TRUE,order.getId(), 2L, userId);
//        }

    }

    @PostMapping("/auto/emptyIn/v1")
    @ResponseBody
    public R autoEmptyIn(@RequestBody LocTypeDto locTypeDto){
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(12, true);

        // 检索库位
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();

        StartupDto dto = commonService.getLocNo( 10, 12, findLocNoAttributeVo, locTypeDto);
        Date now = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(dto.getWorkNo());
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(1L);
        wrkMast.setIoPri(13D);
        wrkMast.setIoType(10);
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
        wrkMast.setLocNo(dto.getLocNo());
        wrkMast.setFullPlt("N"); // 满板：N
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("Y"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
        // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        wrkMast.setMemo("自动空托入库");
        return wrkMastService.insert(wrkMast) ? R.ok("自动空托入库成功,工作号:"+wrkMast.getWrkNo()) : R.error("生成自动空托入库失败");
    }

    @PostMapping("auto/emptyOut/v1")
    @ResponseBody
    public R autoEmptyOut(@RequestBody Map<String,String> emptyPalletSite){
        // 空托盘类型
        String type = emptyPalletSite.get("flag");
        // 出库站点
        Integer site = Integer.valueOf(emptyPalletSite.get("site"));

        LocMast locMast;

        // 先找浅库位
        locMast = locMastMapper.queryLocMasterByLocStsAndRow(Arrays.asList(2, 3), type);

        // 浅库位没有则查询所有
        if (locMast == null) {
            locMast = locMastMapper.queryLocMasterByLocStsAndRow(null, type);
        }

        if (locMast == null) {
            return R.error("库存没有"+type+"类型空托盘");
        }

        String locNo = locMast.getLocNo();

        EmptyPlateOutParam emptyPlateOutParam = new EmptyPlateOutParam();
        emptyPlateOutParam.setOutSite(site);
        emptyPlateOutParam.setLocNos(new ArrayList<String>(){{add(locNo);}});
        WrkMast wrkMast = workService.emptyPlateOut(emptyPlateOutParam);
        return R.ok(!Cools.isEmpty(wrkMast)? R.ok("自动空托出库成功,工作号:" + wrkMast.getWrkNo()) : R.error("生成自动空托出库失败"));
    }

    /**
     * 全板入库
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public StartupDto startupFullPutStore(Integer devpNo, String barcode, LocTypeDto locTypeDto, WaitPakin waitPakins, int locArea,boolean tailSupportFlag) {
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
//        List<String> matnrs = waitPakins.stream().map(WaitPakin::getMatnr).distinct().collect(Collectors.toList());
//        List<String> batchs = waitPakins.stream().map(WaitPakin::getBatch).distinct().collect(Collectors.toList());
//        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo(matnrs.get(0), batchs.get(0));
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo(waitPakins);
        StartupDto dto = commonService.getLocNoNew( 1, devpNo,findLocNoAttributeVo, locArea);
        int workNo = dto.getWorkNo();
        Date now = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(2L); // 工作状态：生成入库ID
        wrkMast.setIoType(1); // 入出库状态：1.入库
        wrkMast.setIoPri(13D); // 优先级
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
        wrkMast.setLocNo(dto.getLocNo());
        wrkMast.setBarcode(barcode); // 托盘码
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setCtnType(tailSupportFlag ? 1 : 0); // 尾托标识
        wrkMast.setPdcType(waitPakins.getModel()); // 空桶类型
        // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
        }
        // 生成工作档明细
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(waitPakins);
            wrkDetl.setWrkNo(wrkMast.getWrkNo());
            wrkDetl.setIoTime(wrkMast.getIoTime());
            wrkDetl.setAppeTime(now);
            wrkDetl.setModiTime(now);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作明细失败");
            }
        // 更新入库通知档 ioStatus ===>> Y
        Wrapper<WaitPakin> wrapper = new EntityWrapper<WaitPakin>()
                .eq("zpallet", barcode);
        WaitPakin setParam = new WaitPakin();
        setParam.setLocNo(dto.getLocNo());
        setParam.setIoStatus("Y");
        setParam.setModiTime(now);
        if (!waitPakinService.update(setParam, wrapper)) {
            throw new CoolException("更新通知档失败");
        }
        // 更新源站点信息
        sourceStaNo.setWrkNo(workNo);
        sourceStaNo.setModiTime(now);
        if (!basDevpService.updateById(sourceStaNo)){
            throw new CoolException("更新源站失败");
        }
        // 更新目标库位状态
        LocMast locMast = locMastService.selectById(dto.getLocNo());
        if (locMast.getLocSts().equals("O")){
            locMast.setLocSts("S"); // S.入库预约
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)){
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(dto.getLocNo()+"目标库位已被占用");
        }
        return dto;
    }

    /**
     * 直供罐装线
     */
    @Transactional(propagation = Propagation.REQUIRED)
    public StartupDto startupFullPutStore(SearchLocParam param,WaitPakin waitPakin) {

        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(param.getSourceStaNo(), true);

        String model = waitPakin.getModel();

        Integer wantBucketFlag = 0; // 罐装线号
        String wantBucketType; // 桶类型
        boolean flag = true;
        for(Map.Entry<Integer,String> entry :param.getWantBucketFlag().entrySet()) {
            wantBucketFlag = entry.getKey();
            wantBucketType = entry.getValue();
            if(model.equals(wantBucketType)) { // 当前桶类型是罐装线要的类型
                // 空桶库无该类型桶
                int count = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("model", model).where("CAST(SUBSTRING(loc_no, 1, 2) as int) >= 9"));
                if (count == 0) {
                    flag = false;
                    break;
                }
            }
        }
        if (flag) { // 不满足直供罐装线条件
             return null;
        }

        StartupDto dto = commonService.getLocNo(param,wantBucketFlag);
        int workNo = dto.getWorkNo();
        Date now = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(2L); // 工作状态：生成入库ID
        wrkMast.setIoType(2); // 入出库状态：2.直供罐装线
        wrkMast.setIoPri(13D); // 优先级
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
//        wrkMast.setLocNo(dto.getLocNo());
        wrkMast.setBarcode(param.getBarcode()); // 托盘码
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setCtnType(param.isTailSupportFlag() ? 1 : 0); // 尾托标识
        wrkMast.setPdcType(model); // 空桶类型
        // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiTime(now);
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
        }
        // 生成工作档明细
        WrkDetl wrkDetl = new WrkDetl();
        wrkDetl.sync(waitPakin);
        wrkDetl.setWrkNo(wrkMast.getWrkNo());
        wrkDetl.setIoTime(wrkMast.getIoTime());
        wrkDetl.setAppeTime(now);
        wrkDetl.setModiTime(now);
        if (!wrkDetlService.insert(wrkDetl)) {
            throw new CoolException("保存工作明细失败");
        }
        // 更新入库通知档 ioStatus ===>> Y
        Wrapper<WaitPakin> wrapper = new EntityWrapper<WaitPakin>()
                .eq("zpallet", param.getBarcode());
        WaitPakin setParam = new WaitPakin();
        setParam.setLocNo(dto.getLocNo());
        setParam.setIoStatus("Y");
        setParam.setModiTime(now);
        if (!waitPakinService.update(setParam, wrapper)) {
            throw new CoolException("更新通知档失败");
        }
        // 更新源站点信息
        sourceStaNo.setWrkNo(workNo);
        sourceStaNo.setModiTime(now);
        if (!basDevpService.updateById(sourceStaNo)){
            throw new CoolException("更新源站失败");
        }

        return dto;
    }

    @Transactional
    public StartupDto emptyPlateIn(Integer devpNo, LocTypeDto locTypeDto, String barcode, int locArea) {
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();

        StartupDto dto = commonService.getLocNoNew( 10, devpNo, findLocNoAttributeVo, locArea);
        int workNo = dto.getWorkNo();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(new Date());
        wrkMast.setWrkSts(2L); // 工作状态：生成入库ID
        wrkMast.setIoType(10); // 入出库状态：10.空板入库
        wrkMast.setIoPri(13D); // 优先级
        wrkMast.setCrnNo(dto.getCrnNo());
        wrkMast.setSourceStaNo(dto.getSourceStaNo());
        wrkMast.setStaNo(dto.getStaNo());
        wrkMast.setLocNo(dto.getLocNo());
        wrkMast.setFullPlt("N"); // 满板
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("Y"); // 空板
        wrkMast.setLinkMis("Y");
        wrkMast.setBarcode(barcode);
        wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
        // 操作人员数据
        wrkMast.setAppeTime(new Date());
        wrkMast.setModiTime(new Date());
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
        }
        // 更新源站点信息
        sourceStaNo.setWrkNo(workNo);
        sourceStaNo.setModiTime(new Date());
        if (!basDevpService.updateById(sourceStaNo)){
            throw new CoolException("更新源站失败");
        }
        // 更新目标库位状态
        LocMast locMast = locMastService.selectById(dto.getLocNo());
        if (locMast.getLocSts().equals("O")){
            locMast.setLocSts("S"); // S.入库预约
            locMast.setModiTime(new Date());
            if (!locMastService.updateById(locMast)){
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(dto.getLocNo()+"目标库位已被占用");
        }
        return dto;
    }

}