package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
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.DateUtils;
import com.core.common.SnowflakeIdWorker;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.*;
import com.zy.asrs.entity.result.FindLocNoAttributeVo;
import com.zy.asrs.entity.result.WrkCancel;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.*;
import com.zy.common.model.enums.IoWorkType;
import com.zy.common.model.enums.WorkNoType;
import com.zy.common.properties.SlaveProperties;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
import com.zy.common.web.WcsController;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.stream.Collectors;

/**
 * Created by vincent on 2020/6/11
 */
@Slf4j
@Service
public class WorkServiceImpl implements WorkService {

    // 工作号生成规则默认类型
    private static final int DEFAULT_WORK_NO_TYPE = 0;
    // 库位排号分配默认类别
    private static final int DEFAULT_ROW_NO_TYPE = 1;

    @Autowired
    private MatService matService;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private BasDevpService basDevpService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private LocMastService locMastService;
    @Autowired
    private StaDescService staDescService;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private AdjDetlService adjDetlService;
    @Autowired
    private WrkMastLogService wrkMastLogService;
    @Autowired
    private WrkDetlLogService wrkDetlLogService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private WcsController wcsController;
    @Autowired
    private RowLastnoService rowLastnoService;
    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private WaitPakinService waitPakinService;
    @Autowired
    private ApiLogService apiLogService;
    @Value("${wcs-slave.cancel}")
    private String cancel;
    @Value("${wcs-slave.url}")
    private String url;
    @Value("${wcs-slave.warehouse}")
    private String warehouse;

    @Override
    @Transactional
    public String startupFullPutStore(FullStoreParam param, Long userId) {
        // 参数非空判断
        if (Cools.isEmpty(param.getDevpNo(), param.getList())) {
            throw new CoolException(BaseRes.PARAM);
        }
        Date now = new Date();
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(param.getDevpNo(), true);
        // 检索库位
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        List<String> matnrs = param.getList().stream().map(FullStoreParam.MatCodeStore::getMatnr).distinct().collect(Collectors.toList());
//        List<String> batchs = param.getList().stream().map(FullStoreParam.MatCodeStore::getBatch).distinct().collect(Collectors.toList());
        StartupDto dto = commonService.getLocNo(1, param.getDevpNo(), matnrs.get(0), null, null,locTypeDto);
        if (Cools.isEmpty(dto)){
            throw new CoolException("查询库位失败！！==》startupFullPutStore ==》 commonService.getLocNo");
        }
        // 生成工作号
        int workNo = dto.getWorkNo();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(1L); // 工作状态：生成入库ID
        wrkMast.setIoType(1); // 入出库状态：1.入库
        wrkMast.setIoPri(13D); // 优先级：13
        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("N");
        wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
        wrkMast.setAppeUser(userId);
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(now);
        if (!wrkMastService.insert(wrkMast)) {
            throw new CoolException("保存工作档失败");
        }
        // 生成工作档明细
        List<DetlDto> detlDtos = new ArrayList<>();
        param.getList().forEach(elem -> {
            DetlDto detlDto = new DetlDto(elem.getMatnr(), elem.getBatch(), elem.getAnfme());
            if (DetlDto.has(detlDtos, detlDto)) {
                DetlDto detlDto1 = DetlDto.find(detlDtos, detlDto.getMatnr(), detlDto.getBatch());
                assert detlDto1 != null;
                detlDto1.setAnfme(detlDto1.getAnfme() + detlDto.getAnfme());
            } else {
                detlDtos.add(detlDto);
            }
        });
        wrkDetlService.createWorkDetail(workNo, detlDtos, param.getBarcode(), userId, now);
        // 更新源站点信息
        sourceStaNo.setWrkNo(workNo);
        sourceStaNo.setModiUser(userId);
        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.setModiUser(userId);
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)){
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(dto.getLocNo()+"目标库位已被占用");
        }
        return dto.getLocNo();
    }

    @Override
    @Transactional
    public void startupFullTakeStore(StockOutParam param, Long userId) {
        // 目标站点状态检测
        BasDevp staNo = basDevpService.checkSiteStatus(param.getOutSite());
        // 获取库位明细
        List<LocDetlDto> locDetlDtos = new ArrayList<>();
        for (StockOutParam.LocDetl paramLocDetl : param.getLocDetls()) {
            if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getCount())) {
                LocDetl one = locDetlService.selectItem(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getBatch());
                if (null != one) locDetlDtos.add(new LocDetlDto(one, paramLocDetl.getCount()));
            }
        }
        if (!locDetlDtos.isEmpty()) {
            // 启动出库开始 101.出库
            stockOut(staNo, locDetlDtos, null, userId);
        } else {
            throw new CoolException("库存不存在");
        }
    }
    private boolean isInNormalRule(LocMast lm) {
        List<LocGroupOrder> locGroupAscOrder = slaveProperties.getLocGroupAscOrder();
        if (locGroupAscOrder == null || locGroupAscOrder.isEmpty()) {
            return false;
        }
        Integer row = lm.getRow1();
        if (row == null) return false;

        return locGroupAscOrder.stream()
                .anyMatch(group ->
                        group.getRowList() != null &&
                                group.getRowList().contains(row)
                );
    }

    /**
     * 检查正常库位前方是否堵塞（深库位规则：前方排是否有货或入库任务）
     *
     * 判断依据：
     * 1. 只检查属于出库分组规则内的库位（通过分组的 rowList 确定范围）
     * 2. 前方 = 分组中索引大于当前库位的排（假设分组 rowList 已按出库顺序排列，大索引 = 前方更深）
     * 3. 堵塞条件：前方有货（F状态）或有入库任务
     *
     * @param normalMasts 需要检查的正常库位列表（已通过 isInNormalRule 过滤）
     * @return true = 前方有堵塞（需要补齐），false = 前方清空或无需检查
     */
    private boolean checkDeepLocationBlocked(List<LocMast> normalMasts) {
        if (normalMasts == null || normalMasts.isEmpty()) {
            return false;
        }

        // 获取出库分组配置
        List<LocGroupOrder> locGroupAscOrder = slaveProperties.getLocGroupAscOrder();
        if (locGroupAscOrder == null || locGroupAscOrder.isEmpty()) {
            return false; // 无配置时默认不检查
        }

        // 假设所有 normalMasts 在同一个分组（常见情况，若多分组可循环处理）
        LocMast representative = normalMasts.get(0);
        LocGroupOrder group = locGroupAscOrder.stream()
                .filter(g -> g.getRowList() != null && g.getRowList().contains(representative.getRow1()))
                .findFirst()
                .orElse(null);

        if (group == null || group.getRowList() == null || group.getRowList().isEmpty()) {
            return false; // 不在任何分组，不检查
        }

        List<Integer> fullRows = group.getRowList(); // 分组内所有排号列表（按出库顺序排列）

        // 遍历每个正常库位
        for (LocMast lm : normalMasts) {
            Integer currentRow = lm.getRow1();
            Integer bay1 = lm.getBay1();
            Integer lev1 = lm.getLev1();

            if (currentRow == null || bay1 == null || lev1 == null) {
                continue;
            }

            // 在分组 rowList 中找到当前排的索引
            int currentIndex = fullRows.indexOf(currentRow);
            if (currentIndex < 0) {
                continue; // 当前排不在分组内，跳过
            }

            // 前方 = 分组中索引更大的位置（假设分组 rowList 从前到后排列，大索引 = 更深）
            // 如果你的分组列表是倒序的（从后到前），则需改为 currentIndex - 1 到 0
            for (int i = currentIndex + 1; i < fullRows.size(); i++) {
                Integer frontRow = fullRows.get(i);
                LocMast front = getLocMastByRow(frontRow, bay1, lev1);
                if (front == null) {
                    continue;
                }

                // 有货（F状态） → 堵塞
                if ("F".equals(front.getLocSts())) {
                    return true;
                }

                WrkMast frontTask = wrkMastService.selectOne(
                        new EntityWrapper<WrkMast>()
                                .eq("source_loc_no", front.getLocNo())
                                .in("loc_sts", Arrays.asList("S", "Q")) // 支持 loc_sts 为 S 或 Q
                );

                if (frontTask != null) {
                    return true;
                }
            }
        }

        // 所有正常库位前方都清空（或无前方）
        return false;
    }
    @Override
    @Transactional
    public void stockOut(BasDevp staNo, List<LocDetlDto> locDetlDtos, IoWorkType ioWorkType, Long userId) {
        Date now = new Date();

        // 保留：合并同类项（同一库位合并明细）
        Set<String> locNos = new HashSet<>();
        List<OutLocDto> dtos = new ArrayList<>();
        for (LocDetlDto locDetlDto : locDetlDtos) {
            String locNo = locDetlDto.getLocDetl().getLocNo();
            if (locNos.contains(locNo)) {
                for (OutLocDto dto : dtos) {
                    if (dto.getLocNo().equals(locNo)) {
                        dto.getLocDetlDtos().add(locDetlDto);
                        break;
                    }
                }
            } else {
                locNos.add(locNo);
                dtos.add(new OutLocDto(locNo, locDetlDto));
            }
        }
        // 使用出库专用分组配置
        List<LocGroupOrder> locGroupAscOrder = slaveProperties.getLocGroupAscOrder();
        // 确定正常出库类型（和原来保持类似）
        int ioTypeNormal = 101; // 默认整托出库
        if (ioWorkType != null && ioWorkType.equals(IoWorkType.CHECK_OUT)) {
            ioTypeNormal = 107;
        } else if (!dtos.isEmpty() && !dtos.get(0).isAll()) {
            ioTypeNormal = 103; // 部分出库
        }

        // 1. 查询所有选中的库位主信息
        List<LocMast> allSelectedMasts = locMastService.selectList(
                new EntityWrapper<LocMast>().in("loc_no", locNos)
        );

        if (allSelectedMasts.size() != locNos.size()) {
            throw new CoolException("部分选中库位不存在或数据异常");
        }

        // 2. 区分正常库位（需要严格深库位检查）与补充库位
        List<LocMast> normalMasts = new ArrayList<>();
        List<LocMast> supplementMasts = new ArrayList<>();

        // 假设我们有某种“分组规则”（如按列层或排范围），这里简化用一个示例判断
        // 你可以替换成实际的规则（如 getLocGroupOrderOut() 或其他）
        for (LocMast lm : allSelectedMasts) {
            boolean isNormal = isInNormalRule(lm); // ← 你需要实现这个判断方法
            if (isNormal) {
                normalMasts.add(lm);
            } else {
                supplementMasts.add(lm);
            }
        }

        // 3. 对正常库位进行深库位前方检查（类似之前的连续段 + 清空）
        AtomicReference<Boolean> isLeftSideSupplement = new AtomicReference<>(false);

        if (!normalMasts.isEmpty()) {
            // 这里模拟深库位前方检查（你可以替换成你实际的检查方法）
            boolean hasBlockage = checkDeepLocationBlocked(normalMasts);

            if (hasBlockage) {
                // 前方堵塞 → 自动补充最少一侧
                supplementBothSidesBlocked(normalMasts, locGroupAscOrder, supplementMasts, isLeftSideSupplement);
            }
        }

        // 4. 合并所有要出库的库位
        List<LocMast> allMasts = new ArrayList<>();
        allMasts.addAll(normalMasts);
        allMasts.addAll(supplementMasts);

        if (allMasts.isEmpty()) {
            throw new CoolException("没有有效的出库库位");
        }

        // 5. 统一按排号（row）倒序排序（高排先出）
        List<LocMast> sortedAll = allMasts.stream()
                .sorted(Comparator.comparing(LocMast::getRow1, Comparator.reverseOrder()))
                .collect(Collectors.toList());

        // 6. 生成任务（从后往前遍历）
        double basePriority = 100.0;
        for (int index = sortedAll.size() - 1; index >= 0; index--) {
            LocMast locMast = sortedAll.get(index);
            String locNo = locMast.getLocNo();

            boolean isSupplement = supplementMasts.contains(locMast);
            int ioType = isSupplement ? 11 : ioTypeNormal;
            // 优先级计算
            double priority;
            if (isSupplement) {
                if (Boolean.TRUE.equals(isLeftSideSupplement.get())) {
                    // 左侧补充 → 晚出
                    priority = basePriority - index * 1.0;
                } else {
                    // 右侧补充 → 早出
                    priority = basePriority + index * 1.0;
                }
            } else {
                priority = basePriority - index * 1.0;
            }
            OutLocDto dto;
            Integer outSta = staNo.getDevNo();
            StaDesc staDesc = null;
            if(ioType != 11){
                staDesc = staDescService.queryCrnStn(ioType, locMast.getCrnNo(), outSta);
            }
            LocMast locMastNew = null;
            WrkMast wrkMast = new WrkMast();
            String locSts;
            int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));
            String pick = (ioType == 101) ? "N" : "Y";
            if((ioType == 101 || ioType == 103 || ioType == 107) && staDesc != null) {
                // 找到对应的 OutLocDto
                dto = dtos.stream()
                        .filter(d -> d.getLocNo().equals(locNo))
                        .findFirst()
                        .orElseThrow(() -> new CoolException("找不到对应的出库明细：" + locNo));
                // 生成工作档
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(now);
                wrkMast.setWrkSts(0L);
                wrkMast.setIoType(ioType);
                wrkMast.setIoPri(priority);
                wrkMast.setCrnNo(locMast.getCrnNo());
                wrkMast.setSourceStaNo(staDesc.getCrnStn());
                wrkMast.setStaNo(staDesc.getStnNo());
                wrkMast.setSourceLocNo(locNo);
                wrkMast.setFullPlt("Y");
                wrkMast.setPicking(pick);
                wrkMast.setExitMk("N");
                wrkMast.setEmptyMk("N");
                wrkMast.setLinkMis("N");
                wrkMast.setBarcode(locMast.getBarcode());
                wrkMast.setAppeUser(userId);
                wrkMast.setAppeTime(now);
                wrkMast.setModiUser(userId);
                wrkMast.setModiTime(now);
                locSts = ioType != 101? "R" : "P";
                // 生成工作档明细（保留原逻辑）
                for (LocDetlDto detlDto : dto.getLocDetlDtos()) {
                    if (detlDto.getCount() == null || detlDto.getCount() <= 0.0D) {
                        continue;
                    }
                    WrkDetl wrkDetl = new WrkDetl();
                    wrkDetl.sync(detlDto.getLocDetl());
                    wrkDetl.setOrderNo("");
                    wrkDetl.setWrkNo(workNo);
                    wrkDetl.setIoTime(now);
                    Double anfme = ioType == 101 ? detlDto.getLocDetl().getAnfme() : detlDto.getCount();
                    wrkDetl.setAnfme(anfme);
                    wrkDetl.setAppeTime(now);
                    wrkDetl.setAppeUser(userId);
                    wrkDetl.setModiTime(now);
                    wrkDetl.setModiUser(userId);
                    if (!wrkDetlService.insert(wrkDetl)) {
                        throw new CoolException("保存工作档明细失败");
                    }
                }
            }else{
                List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no",locNo));
                FindLocNoAttributeVo findLocNoAttributeVo = new FindLocNoAttributeVo();
                findLocNoAttributeVo.setMatnr(locDetls.get(0).getMatnr());
                findLocNoAttributeVo.setBatch(locDetls.get(0).getBatch());
                LocTypeDto locTypeDto = new LocTypeDto();
                locTypeDto.setLocType1(locMast.getLocType1());
                locMastNew = commonService.searchMaxPallet(findLocNoAttributeVo,locTypeDto);
                // 生成工作档
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(now);
                wrkMast.setWrkSts(0L);
                wrkMast.setIoType(ioType);
                wrkMast.setIoPri(priority);
                wrkMast.setCrnNo(locMast.getCrnNo());
                wrkMast.setSourceStaNo(null);
                wrkMast.setStaNo(null);
                wrkMast.setSourceLocNo(locNo);
                wrkMast.setLocNo(locMastNew.getLocNo());
                wrkMast.setFullPlt("Y");
                wrkMast.setPicking(pick);
                wrkMast.setExitMk("N");
                wrkMast.setEmptyMk("N");
                wrkMast.setLinkMis("N");
                wrkMast.setBarcode(locMast.getBarcode());
                wrkMast.setAppeUser(userId);
                wrkMast.setAppeTime(now);
                wrkMast.setModiUser(userId);
                wrkMast.setModiTime(now);
                locSts = "R";
                // 生成工作档明细（保留原逻辑）
                if(locDetls != null && locDetls.size() > 0) {
                    for (LocDetl locDetl : locDetls) {
                        WrkDetl wrkDetl = new WrkDetl();
                        wrkDetl.sync(locDetl);
                        wrkDetl.setWrkNo(workNo);
                        wrkDetl.setIoTime(now);

                        wrkDetl.setAppeTime(now);
                        wrkDetl.setAppeUser(userId);
                        wrkDetl.setModiTime(now);
                        wrkDetl.setModiUser(userId);
                        if (!wrkDetlService.insert(wrkDetl)) {
                            throw new CoolException("保存工作档明细失败");
                        }
                    }
                }
            }
            if (!wrkMastService.insert(wrkMast)) {
                throw new CoolException("保存工作档失败，库位：" + locNo);
            }

            if(locMastNew != null){
                if ("O".equals(locMastNew.getLocSts())) {
                    locMastNew.setLocSts("S");
                    locMastNew.setModiUser(userId);
                    locMastNew.setModiTime(now);
                    if (!locMastService.updateById(locMastNew)) {
                        throw new CoolException("更新库位状态失败，库位：" + locNo);
                    }
                } else {
                    throw new CoolException("库位状态异常，非空板状态：" + locNo);
                }
            }
            // 更新库位状态
            locMast = locMastService.selectById(locNo);
            if ("F".equals(locMast.getLocSts())) {
                locMast.setLocSts(locSts);
                locMast.setModiUser(userId);
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("预约库位状态失败，库位号：" + locNo);
                }
            } else {
                throw new CoolException(locNo + " 库位不是在库状态");
            }
        }
    }

    @Override
    @Transactional
    public void stockOut(BasDevp staNo, TaskDto taskDto, Long userId) {
        Date now = new Date();
        List<LocDto> locDtos = taskDto.getLocDtos();
        for (LocDto locDto : locDtos) {
            if (!taskDto.getLocNo().equals(locDto.getLocNo()) && !taskDto.getStaNo().equals(locDto.getStaNo())) {
                throw new CoolException("订单出库异常，请联系管理员");
            }
        }
        // 获取库位
        LocMast locMast = locMastService.selectById(taskDto.getLocNo());
        // 获取路径
        int ioType = taskDto.isAll() ? 101 : 103;
        StaDesc staDesc = staDescService.queryCrnStnAuto(ioType, locMast.getCrnNo(), staNo.getDevNo());
        // 生成工作号
        int workNo = commonService.getWorkNo(WorkNoType.getWorkNoType(ioType));
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
        wrkMast.setIoType(ioType); // 入出库状态
        wrkMast.setIoPri(13D); // 优先级：13
        wrkMast.setCrnNo(locMast.getCrnNo());
        wrkMast.setSourceStaNo(staDesc.getCrnStn()); // 源站
        wrkMast.setStaNo(staDesc.getStnNo()); // 目标站
        wrkMast.setSourceLocNo(taskDto.getLocNo()); // 源库位
        wrkMast.setFullPlt("Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk("N"); // 空板
        wrkMast.setLinkMis("N");
        wrkMast.setBarcode(locMast.getBarcode());
        wrkMast.setAppeUser(userId); // 操作人员数据
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(now);
        if (!wrkMastService.insert(wrkMast)) {
            throw new CoolException("保存工作档失败，出库库位号："+taskDto.getLocNo());
        }
        // 生成工作档明细
        for (LocDto locDto : taskDto.getLocDtos()) {
            if (locDto.getAnfme()==null || locDto.getAnfme() <= 0.0D) { continue; }
            OrderDetl orderDetl = orderDetlService.selectItem(locDto.getOrderNo(), locDto.getMatnr(), locDto.getBatch());
            if (orderDetl == null) {
                orderDetl = orderDetlService.selectItem(locDto.getOrderNo(), locDto.getMatnr(), null);
            }
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(orderDetl);
            wrkDetl.setZpallet(wrkMast.getBarcode());
            wrkDetl.setIoTime(now);
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setBatch(locDto.getBatch());
            wrkDetl.setOrderNo(locDto.getOrderNo());
            wrkDetl.setAnfme(locDto.getAnfme()); // 数量
            wrkDetl.setAppeTime(now);
            wrkDetl.setAppeUser(userId);
            wrkDetl.setModiTime(now);
            wrkDetl.setModiUser(userId);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作档明细失败");
            }
            // 修改订单明细
            if (!orderDetlService.increaseWorkQty(orderDetl.getOrderId(), orderDetl.getMatnr(), orderDetl.getBatch(), locDto.getAnfme())) {
                throw new CoolException("修改订单明细数量失败");
            }
            orderService.updateSettle(orderDetl.getOrderId(), 2L, userId);
        }
        // 修改库位状态:   F.在库 ====>>> R.出库预约/P.拣料/盘点/并板出库中
        locMast = locMastService.selectById(taskDto.getLocNo());
        if (locMast.getLocSts().equals("F")) {
            locMast.setLocSts(ioType==101?"R":"P");
            locMast.setModiUser(userId);
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)) {
                throw new CoolException("预约库位状态失败，库位号："+taskDto.getLocNo());
            }
        } else {
            throw new CoolException(taskDto.getLocNo() + "库位不是在库状态");
        }
    }

    @Override
    @Transactional
    public String emptyPlateIn(Integer devpNo, Long userId) {
        // 源站点状态检测
        BasDevp sourceStaNo = basDevpService.checkSiteStatus(devpNo, true);
        // 检索库位
        LocTypeDto locTypeDto = new LocTypeDto(sourceStaNo);
        StartupDto dto = commonService.getLocNo( 10, devpNo, null,null,null, locTypeDto);
        int workNo = dto.getWorkNo();
        Date now = new Date();
        // 生成工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(1L); // 工作状态：生成入库ID
        wrkMast.setIoType(10); // 入出库状态：10.空板入库
        wrkMast.setIoPri(10D); // 优先级：10
        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("N");
        wrkMast.setCtnType(sourceStaNo.getCtnType()); // 容器类型
        // 操作人员数据
        wrkMast.setAppeUser(userId);
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(now);
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
        }
        // 更新源站点信息
        sourceStaNo.setWrkNo(workNo);
        sourceStaNo.setModiUser(userId);
        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.setModiUser(userId);
            locMast.setModiTime(now);
            if (!locMastService.updateById(locMast)){
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(dto.getLocNo()+"目标库位已被占用");
        }
        return dto.getLocNo();
    }

    /**
     * 检查空板出库分组内选中连续段的双向前方清空情况，并返回出库方向与排序后的库位列表
     *
     * @param selectedLocNos 选中的库位号列表
     * @param locGroupAscOrder 出库分组配置
     * @return LockingCheckResultParam 包含校验结果、方向、排序后库位列表
     */
    private LockingCheckResultParam checkEmptyPlateBlocking(
            List<String> selectedLocNos,
            List<LocGroupOrder> locGroupAscOrder) {

        if (Cools.isEmpty(selectedLocNos)) {
            return LockingCheckResultParam.success(Collections.emptyList());
        }

        // 1. 查询所有选中的库位信息
        List<LocMast> selectedMasts = locMastService.selectList(
                new EntityWrapper<LocMast>().in("loc_no", selectedLocNos)
        );

        if (selectedMasts.size() != selectedLocNos.size()) {
            return LockingCheckResultParam.fail("部分选中库位不存在或数据异常");
        }

        // 2. 按分组聚合选中的库位（支持多分组）
        Map<LocGroupOrder, List<LocMast>> groupSelected = new HashMap<>();
        for (LocMast lm : selectedMasts) {
            LocGroupOrder group = locGroupAscOrder.stream()
                    .filter(g -> g.getRowList().contains(lm.getRow1()))
                    .findFirst()
                    .orElseThrow(() -> new CoolException("排不在出库分组配置中: row=" + lm.getRow1()));

            groupSelected.computeIfAbsent(group, k -> new ArrayList<>()).add(lm);
        }

        // 由于通常一次请求在一个分组内，这里取第一个分组的结果
        // 如果需要支持多分组同时出库，可改为返回 Map<LocGroupOrder, LockingCheckResultParam>
        LockingCheckResultParam result = null;

        for (Map.Entry<LocGroupOrder, List<LocMast>> entry : groupSelected.entrySet()) {
            LocGroupOrder group = entry.getKey();
            List<LocMast> selected = entry.getValue();

            List<Integer> fullRows = group.getRowList();  // 如 [3,4,5,6,7,8,9,10]

            // 获取选中的 row，并按分组顺序排序
            List<Integer> selectedRows = selected.stream()
                    .map(LocMast::getRow1)
                    .distinct()
                    .sorted(Comparator.comparingInt(fullRows::indexOf))
                    .collect(Collectors.toList());

            // 检查是否重复或无效
            if (selectedRows.size() != selected.size()) {
                return LockingCheckResultParam.fail("选中库位存在重复或无效排");
            }

            int minIndex = fullRows.indexOf(selectedRows.get(0));
            int maxIndex = fullRows.indexOf(selectedRows.get(selectedRows.size() - 1));

            // 1. 必须是连续段（无缺口）
            if (maxIndex - minIndex + 1 != selectedRows.size()) {
                return LockingCheckResultParam.fail(
                        "选中排必须连续，无缺口。从 " + fullRows.get(minIndex) + " 到 " + fullRows.get(maxIndex)
                );
            }

            // 2. 检查左前方（正序方向：从左到右，前方是索引小的位置）
            boolean leftClear = true;
            for (int i = 0; i < minIndex; i++) {
                LocMast prev = getLocMastByRow(fullRows.get(i), selected.get(0).getBay1(), selected.get(0).getLev1());
                if (prev != null && ("D".equals(prev.getLocSts()) || "F".equals(prev.getLocSts()))) {
                    leftClear = false;
                    break;
                }
            }

//            // 3. 检查右前方（倒序方向：从右到左，前方是索引大的位置）
//            boolean rightClear = true;
//            for (int i = maxIndex + 1; i < fullRows.size(); i++) {
//                LocMast prev = getLocMastByRow(fullRows.get(i), selected.get(0).getBay1(), selected.get(0).getLev1());
//                if (prev != null && ("D".equals(prev.getLocSts()) || "F".equals(prev.getLocSts()))) {
//                    rightClear = false;
//                    break;
//                }
//            }

            // 4. 至少有一侧清空才允许出库（修改：放宽，如果两侧都堵，返回特定错误码或继续）
//            if (!leftClear && !rightClear) {
//                return LockingCheckResultParam.fail(
//                        "选中段 " + fullRows.get(minIndex) + "~" + fullRows.get(maxIndex) +
//                                " 两侧前方都有空板/故障，无法出库（正序或倒序方向都堵塞）"
//                );
//            }
            if (!leftClear ) {
                return LockingCheckResultParam.fail(
                        "选中段 " + fullRows.get(minIndex) + "~" + fullRows.get(maxIndex) +
                                " 两侧前方都有空板/故障，无法出库（正序或倒序方向都堵塞）"
                );
            }

            // 5. 选中段内所有库位必须是 D 状态
            for (LocMast lm : selected) {
                if (!"D".equals(lm.getLocSts())) {
                    return LockingCheckResultParam.fail("选中库位非空板状态: " + lm.getLocNo());
                }
            }

            // 6. 决定出库方向和排序顺序
            String direction;
            List<LocMast> sortedSelected;

            // 优先选择正序（如果两侧都清空，默认正序）
            if (leftClear) {
                direction = "ASC";
                sortedSelected = selected.stream()
                        .sorted(Comparator.comparingInt(m -> fullRows.indexOf(m.getRow1())))
                        .collect(Collectors.toList());
            } else {
                direction = "DESC";
                sortedSelected = selected.stream()
                        .sorted(Comparator.comparingInt(m -> -fullRows.indexOf(m.getRow1()))) // 倒序
                        .collect(Collectors.toList());
            }

            result = LockingCheckResultParam.success(direction, sortedSelected);
        }

        // 如果没有分组（理论上不会发生），返回默认成功
        return result != null ? result : LockingCheckResultParam.success(Collections.emptyList());
    }

    // 辅助方法：根据 row 获取 LocMast
    private LocMast getLocMastByRow(Integer row, Integer bay1, Integer lev1) {
        return locMastService.selectOne(new EntityWrapper<LocMast>()
                .eq("bay1", bay1)
                .eq("lev1", lev1)
                .eq("row1", row));
    }

    /**
     * 当选中段两侧前方都堵塞时，判断补哪一侧需要的空板最少，并把那些库位加入补充列表
     */
    private void supplementBothSidesBlocked(
            List<LocMast> normalMasts,
            List<LocGroupOrder> locGroupAscOrder,
            List<LocMast> supplementMasts,
            AtomicReference<Boolean> isLeftSideSupplement) {

        // 假设所有 normalMasts 在同一个分组（如果多分组，可循环处理每个分组）
        LocGroupOrder group = locGroupAscOrder.stream()
                .filter(g -> g.getRowList().contains(normalMasts.get(0).getRow1()))
                .findFirst()
                .orElseThrow(() -> new CoolException("分组异常"));

        List<Integer> fullRows = group.getRowList();

        // 取选中段的 min/max row
        Set<Integer> selectedRowSet = normalMasts.stream()
                .map(LocMast::getRow1)
                .collect(Collectors.toSet());

        int minRow = Collections.min(selectedRowSet);
        int maxRow = Collections.max(selectedRowSet);

        int minIndex = fullRows.indexOf(minRow);
        int maxIndex = fullRows.indexOf(maxRow);

        // 假设所有库位在同 bay 和 lev
        Integer bay1 = normalMasts.get(0).getBay1();
        Integer lev1 = normalMasts.get(0).getLev1();

        // 计算左侧前方需要补充的 D 状态库位数量（从 0 到 minIndex-1 的 D 状态库位）
        int leftSupplementCount = 0;
        List<LocMast> leftSupplementLocs = new ArrayList<>();
        for (int i = 0; i < minIndex; i++) {
            LocMast loc = getLocMastByRow(fullRows.get(i), bay1, lev1);
            if (loc != null && ("D".equals(loc.getLocSts()) || "F".equals(loc.getLocSts()))) {
                leftSupplementCount++;
                leftSupplementLocs.add(loc);
            }
        }

//        // 计算右侧前方需要补充的 D 状态库位数量（从 maxIndex+1 到 end 的 D 状态库位）
//        int rightSupplementCount = 0;
//        List<LocMast> rightSupplementLocs = new ArrayList<>();
//        for (int i = maxIndex + 1; i < fullRows.size(); i++) {
//            LocMast loc = getLocMastByRow(fullRows.get(i), bay1, lev1);
//            if (loc != null && "D".equals(loc.getLocSts())) {
//                rightSupplementCount++;
//                rightSupplementLocs.add(loc);
//            }
//        }

        // 选择需要补充最少的一侧（如果相等，优先左侧）
        List<LocMast> chosenSupplementLocs;
        boolean isLeft = false;
        if (true) {
            chosenSupplementLocs = leftSupplementLocs;
            isLeft = true;
            log.info("选择补充左侧前方，共 {} 个库位", leftSupplementCount);
        }
//        else {
//            chosenSupplementLocs = rightSupplementLocs;
//            isLeft = false;
//            log.info("选择补充右侧前方，共 {} 个库位", rightSupplementCount);
//        }
        // 记录选择的侧
        isLeftSideSupplement.set(isLeft);
        // 添加到 supplementMasts（避免重复添加）
        for (LocMast supp : chosenSupplementLocs) {
            if (!supplementMasts.contains(supp) && !normalMasts.contains(supp)) {
                supplementMasts.add(supp);
            }
        }
    }

    @Override
    @Transactional
    public void emptyPlateOut(EmptyPlateOutParam param, Long userId) {
        if (Cools.isEmpty(param.getOutSite())) {
            throw new CoolException("站点不存在");
        }

        // 使用出库专用分组配置
        List<LocGroupOrder> locGroupAscOrder = slaveProperties.getLocGroupAscOrder();

        // 1. 查询所有选中的库位信息
        List<LocMast> selectedMasts = locMastService.selectList(
                new EntityWrapper<LocMast>().in("loc_no", param.getLocNos())
        );

        if (selectedMasts.size() != param.getLocNos().size()) {
            throw new CoolException("部分选中库位不存在或数据异常");
        }

        // 2. 区分正常分组内的库位 和 需要补充的库位（规则外的）
        List<LocMast> normalMasts = new ArrayList<>();
        List<LocMast> supplementMasts = new ArrayList<>();
        for (LocMast lm : selectedMasts) {
            boolean inAnyGroup = locGroupAscOrder.stream()
                    .anyMatch(g -> g.getRowList().contains(lm.getRow1()));
            if (inAnyGroup) {
                normalMasts.add(lm);
            } else {
                supplementMasts.add(lm);
            }
        }
        // 新增：记录是否因为左侧前方被补充
        AtomicReference<Boolean> isLeftSideSupplement = new AtomicReference<>(false);
        // 3. 对正常分组内的库位进行检查（放宽两侧堵塞规则）
        if (!normalMasts.isEmpty()) {
            List<String> normalLocNos = normalMasts.stream()
                    .map(LocMast::getLocNo)
                    .collect(Collectors.toList());

            LockingCheckResultParam checkResult = checkEmptyPlateBlocking(
                    normalLocNos,
                    locGroupAscOrder
            );

            if (!checkResult.isSuccess()) {
                String errMsg = checkResult.getErrorMessage();
                if (errMsg.contains("两侧前方都有空板/故障")) {
                    // 两侧都堵 → 进入补齐逻辑
                    supplementBothSidesBlocked(normalMasts, locGroupAscOrder, supplementMasts, isLeftSideSupplement);
                } else {
                    // 其他错误（如不连续、非D状态）抛出
                    throw new CoolException(errMsg);
                }
            }
            // 如果有一侧清空，则正常继续
        }

        // 4. 合并所有库位（正常 + 补充的，包括规则外的和前方补的）
        List<LocMast> allMasts = new ArrayList<>();
        allMasts.addAll(normalMasts);
        allMasts.addAll(supplementMasts);

        if (allMasts.isEmpty()) {
            throw new CoolException("没有有效的空板库位可出库");
        }

        // 5. 统一按 row → bay → lev 排序（从小到大）
        List<LocMast> sortedAll = allMasts.stream()
                .sorted(Comparator.comparing(LocMast::getRow1)
                        .thenComparing(LocMast::getBay1)
                        .thenComparing(LocMast::getLev1))
                .collect(Collectors.toList());

        Date now = new Date();

        // 6. 按排序后的顺序生成出库任务（从后往前生成）
        for (int index = 0; index <sortedAll.size() ; index ++) {
            LocMast locMast = sortedAll.get(index);
            String locNo = locMast.getLocNo();

            // 判断是否为补充库位（规则外的 或 前方补的）
            boolean isSupplement = supplementMasts.contains(locMast);

            int ioType = isSupplement ? 11 : 110;

            // 获取工作号
            int workNo = commonService.getWorkNo(WorkNoType.PAKOUT.type);

            // 获取源站
            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                    .eq("type_no", 110)
                    .eq("stn_no", param.getOutSite())
                    .eq("crn_no", locMast.getCrnNo());
            StaDesc staDesc = staDescService.selectOne(wrapper);
            Integer sourceStaNo = staDesc != null ? staDesc.getCrnStn() : null;

            if (Cools.isEmpty(sourceStaNo)) {
                throw new CoolException("检索源站失败，库位：" + locNo);
            }

            // 计算优先级（示例：补充的优先级稍低）
            double BASE_PRI = 200.0;
            double ioPri;
            WrkMast wrkMast = new WrkMast();
            LocMast locMastNew = null;
            if(isSupplement){
                // 补充的库位：根据是左侧还是右侧补充，决定优先级方向
                if (Boolean.TRUE.equals(isLeftSideSupplement.get())) {
                    // 左侧补充 → 优先级较低（晚出）
                    ioPri = BASE_PRI + index * 1.0;
                } else {
                    // 右侧补充 → 优先级较高（早出）
                    ioPri = BASE_PRI - index * 1.0;
                }
                locMastNew = commonService.searchEmptyPallet(null);
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(now);
                wrkMast.setWrkSts(0L);
                wrkMast.setIoType(ioType);
                wrkMast.setIoPri(ioPri);
                wrkMast.setSourceStaNo(null);
                wrkMast.setLocNo(locMastNew.getLocNo());
                wrkMast.setStaNo(null);
                wrkMast.setCrnNo(locMast.getCrnNo());
                wrkMast.setSourceLocNo(locNo);
                wrkMast.setFullPlt("N");
                wrkMast.setPicking("N");
                wrkMast.setExitMk("N");
                wrkMast.setEmptyMk("Y");
                wrkMast.setLinkMis("N");
                wrkMast.setAppeUser(userId);
                wrkMast.setAppeTime(now);
                wrkMast.setModiUser(userId);
                wrkMast.setModiTime(now);
            }else{
                ioPri = BASE_PRI + index * 1.0;
                wrkMast.setWrkNo(workNo);
                wrkMast.setIoTime(now);
                wrkMast.setWrkSts(0L);
                wrkMast.setIoType(ioType);
                wrkMast.setIoPri(ioPri);
                wrkMast.setSourceStaNo(sourceStaNo);
                wrkMast.setStaNo(param.getOutSite());
                wrkMast.setCrnNo(locMast.getCrnNo());
                wrkMast.setSourceLocNo(locNo);
                wrkMast.setFullPlt("N");
                wrkMast.setPicking("N");
                wrkMast.setExitMk("N");
                wrkMast.setEmptyMk("Y");
                wrkMast.setLinkMis("N");
                wrkMast.setAppeUser(userId);
                wrkMast.setAppeTime(now);
                wrkMast.setModiUser(userId);
                wrkMast.setModiTime(now);
            }

            if (!wrkMastService.insert(wrkMast)) {
                throw new CoolException("保存工作档失败，库位：" + locNo);
            }

            if(locMastNew != null){
                if ("O".equals(locMastNew.getLocSts())) {
                    locMastNew.setLocSts("S");
                    locMastNew.setModiUser(userId);
                    locMastNew.setModiTime(now);
                    if (!locMastService.updateById(locMastNew)) {
                        throw new CoolException("更新库位状态失败，库位：" + locNo);
                    }
                } else {
                    throw new CoolException("库位状态异常，非空板状态：" + locNo);
                }
            }

            // 更新库位状态 D → R
            if ("D".equals(locMast.getLocSts())) {
                locMast.setLocSts("R");
                locMast.setModiUser(userId);
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("更新库位状态失败，库位：" + locNo);
                }
            } else {
                throw new CoolException("库位状态异常，非空板状态：" + locNo);
            }
        }
    }

    @Override
    @Transactional
    public WrkMast emptyPlateOut(EmptyPlateOutParam param) {
        WrkMast wrkMast = new WrkMast();
        if (Cools.isEmpty(param.getOutSite())) {
            throw new CoolException("站点不存在");
        }
        for (String locNo : param.getLocNos()) {
            // 获取工作号
            int workNo = commonService.getWorkNo(0);
            // 获取库位
            LocMast locMast = locMastService.selectById(locNo);
            if (Cools.isEmpty(locMast)) {
                throw new CoolException(locNo+"库位不存在");
            }
            // 获取源站
            Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                    .eq("type_no", 110)
                    .eq("stn_no", param.getOutSite())
                    .eq("crn_no", locMast.getCrnNo());
            StaDesc staDesc = staDescService.selectOne(wrapper);
            Integer sourceStaNo = staDesc.getCrnStn();
            if (Cools.isEmpty(sourceStaNo)) {
                throw new CoolException("检索源站失败");
            }
            Date now = new Date();
            // 保存工作档

            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(now);
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setIoType(110); // 入出库状态： 110.空板出库
            wrkMast.setIoPri(10D);
            wrkMast.setSourceStaNo(sourceStaNo); // 源站
            wrkMast.setStaNo(param.getOutSite()); // 目标站
            wrkMast.setCrnNo(locMast.getCrnNo());
            wrkMast.setSourceLocNo(locNo); // 源库位
            wrkMast.setFullPlt("N"); // 满板：Y
            wrkMast.setPicking("N"); // 拣料
            wrkMast.setExitMk("N"); // 退出
            wrkMast.setEmptyMk("Y"); // 空板
            wrkMast.setLinkMis("N");
            wrkMast.setAppeUser(1L);
            wrkMast.setAppeTime(now);
            wrkMast.setModiUser(1L);
            wrkMast.setModiTime(now);
            wrkMast.setMemo("生成自动空板出库");
            boolean res = wrkMastService.insert(wrkMast);
            if (!res) {
                throw new CoolException("保存工作档失败");
            }
            // 更新库位状态 D.空板 -> R.出库预约
            if (locMast.getLocSts().equals("D")){
                locMast.setLocSts("R");
                locMast.setModiUser(1L);
                locMast.setModiTime(now);
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException("更新库位状态失败");
                }
            }
        }
        return wrkMast;
    }

    @Override
    @Transactional
    public void locCheckOut(StockOutParam param, Long userId) {
        // 目标站点状态检测
        BasDevp staNo = basDevpService.checkSiteStatus(param.getOutSite());
        // 获取库位明细
        List<LocDetlDto> locDetlDtos = new ArrayList<>();
        for (StockOutParam.LocDetl paramLocDetl : param.getLocDetls()) {
            if (!Cools.isEmpty(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getCount())) {
                LocDetl one = locDetlService.selectItem(paramLocDetl.getLocNo(), paramLocDetl.getMatnr(), paramLocDetl.getBatch());
                if (null != one) locDetlDtos.add(new LocDetlDto(one, paramLocDetl.getCount()));
            }
        }
        if (!locDetlDtos.isEmpty()) {
            LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>().eq("loc_no", locDetlDtos.get(0).getLocDetl().getLocNo()));
            if (locMast.getLocSts().equals("F")){
                // 启动出库开始 107.盘点出库
                stockOut(staNo, locDetlDtos, IoWorkType.CHECK_OUT, userId);
            }else {
                throw new CoolException("所选库位存在状态不为F的库位，库位号："+locMast.getLocNo()+" 、当前状态："+locMast.getLocSts()+"-"+locMast.getLocSts$());
            }
        } else {
            throw new CoolException("库位物料不存在");
        }
    }

    @Override
    @Transactional
    public void locMove(String sourceLocNo, String locNo, Long userId) {
        LocMast sourceLoc = locMastService.selectById(sourceLocNo);
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
        if (Cools.isEmpty(sourceLoc)){
            throw new CoolException("未找到库位");
        }
        LocMast loc = locMastService.selectById(locNo);
        if (Cools.isEmpty(loc)){
            throw new CoolException("未找到库位");
        }
        if (!loc.getLocSts().equals("O") || (!sourceLoc.getLocSts().equals("F") && !sourceLoc.getLocSts().equals("D"))){
            throw new CoolException("库位状态已改变");
        }
        if (!sourceLoc.getCrnNo().equals(loc.getCrnNo())) {
            throw new CoolException("移转库位属于不同堆垛机");
        }
        Date now = new Date();
        // 获取工作号
        int workNo = commonService.getWorkNo(WorkNoType.PICK.type);
        // 保存工作档
        WrkMast wrkMast = new WrkMast();
        wrkMast.setWrkNo(workNo);
        wrkMast.setIoTime(now);
        wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
        wrkMast.setIoType(11); // 入出库状态： 11.库格移载
        wrkMast.setIoPri(10D);
        wrkMast.setCrnNo(sourceLoc.getCrnNo());
        wrkMast.setSourceLocNo(sourceLocNo); // 源库位
        wrkMast.setLocNo(locNo); // 目标库位
        wrkMast.setFullPlt(Cools.isEmpty(locDetls)?"N":"Y"); // 满板：Y
        wrkMast.setPicking("N"); // 拣料
        wrkMast.setExitMk("N"); // 退出
        wrkMast.setEmptyMk(sourceLoc.getLocSts().equals("D")?"Y":"N"); // 空板
        wrkMast.setBarcode(sourceLoc.getBarcode()); // 托盘码
        wrkMast.setLinkMis("N");
        wrkMast.setAppeUser(userId);
        wrkMast.setAppeTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(now);
        boolean res = wrkMastService.insert(wrkMast);
        if (!res) {
            throw new CoolException("保存工作档失败");
        }
        // 工作档明细保存
        for (LocDetl locDetl : locDetls) {
            WrkDetl wrkDetl = new WrkDetl();
            wrkDetl.sync(locDetl);
            wrkDetl.setWrkNo(workNo);
            wrkDetl.setIoTime(now);
            wrkDetl.setAnfme(locDetl.getAnfme());
            wrkDetl.setAppeTime(now);
            wrkDetl.setAppeUser(userId);
            wrkDetl.setModiTime(now);
            wrkDetl.setModiUser(userId);
            if (!wrkDetlService.insert(wrkDetl)) {
                throw new CoolException("保存工作档明细失败");
            }
        }
        // 修改源库位状态
        if (sourceLoc.getLocSts().equals("D") || sourceLoc.getLocSts().equals("F")) {
            sourceLoc.setLocSts("R"); // R.出库预约
            sourceLoc.setModiUser(userId);
            sourceLoc.setModiTime(now);
            if (!locMastService.updateById(sourceLoc)){
                throw new CoolException("更新源库位状态失败");
            }
        } else {
            throw new CoolException("源库位出库失败，状态："+sourceLoc.getLocSts$());
        }
        // 修改目标库位状态
        if (loc.getLocSts().equals("O")) {
            loc.setLocSts("S"); // S.入库预约
            loc.setModiTime(now);
            loc.setModiUser(userId);
            if (!locMastService.updateById(loc)) {
                throw new CoolException("更新目标库位状态失败");
            }
        } else {
            throw new CoolException("移转失败，目标库位状态："+loc.getLocSts$());
        }
    }

    @Override
    @Transactional
    public void completeWrkMast(String workNo, Long userId) {
        WrkMast wrkMast = wrkMastService.selectById(workNo);
        if (Cools.isEmpty(wrkMast)){
            throw new CoolException(workNo+"工作档不存在");
        }
        if (wrkMast.getWrkSts() == 4 || wrkMast.getWrkSts() == 14) {
            throw new CoolException("当前工作档已完成");
        }
        // 出库
        if (wrkMast.getIoType() > 100) {
            wrkMast.setWrkSts(14L);
            // 入库 + 库位转移
        } else if (wrkMast.getIoType()==1 || wrkMast.getIoType()==10 || wrkMast.getIoType()==11) {
            wrkMast.setWrkSts(4L);

        }
        Date now = new Date();
        wrkMast.setCrnStrTime(DateUtils.calculate(now, 1L, TimeUnit.SECONDS, true));
        wrkMast.setCrnEndTime(now);
        wrkMast.setModiTime(now);
        wrkMast.setModiUser(userId);
        // 完成操作人员记录
        wrkMast.setManuType("手动完成");
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("修改工作档失败");
        }
    }

    @Override
    @Transactional
    public void adjustLocDetl(LocDetlAdjustParam param, Long userId) {
        param.integrate();
        LocMast locMast = locMastService.selectById(param.getLocNo());
        if (Cools.isEmpty(locMast)) {
            throw new CoolException("库位不存在");
        }
        if (!(locMast.getLocSts().equals("F") || locMast.getLocSts().equals("D") || locMast.getLocSts().equals("O"))) {
            throw new CoolException("当前库位不可调整！库位状态：" + locMast.getLocSts$());
        }

        Date now = new Date();
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", param.getLocNo()));

        List<LocDetlAdjustParam.LocDetlAdjust> list = param.getList();

        // 修改数量
        Iterator<LocDetl> iterator = locDetls.iterator();
        while (iterator.hasNext()) {
            LocDetl locDetl = iterator.next();

            Iterator<LocDetlAdjustParam.LocDetlAdjust> iterator1 = list.iterator();
            while (iterator1.hasNext()) {
                LocDetlAdjustParam.LocDetlAdjust adjust = iterator1.next();
                if (adjust.getCount() == 0) { continue; }
                if (locDetl.getMatnr().equals(adjust.getMatnr()) && Cools.eq(locDetl.getBatch(), adjust.getBatch())) {
                    if (!locDetl.getAnfme().equals(adjust.getCount())) {
                        // todo 盘点记录
                        // 修改库存
                        if (!locDetlService.updateAnfme(adjust.getCount(), locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getBatch())) {
                            throw new CoolException(locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "批号修改数量失败");
                        }
                        // 保存调整记录
                        AdjDetl adjDetl = new AdjDetl();
                        adjDetl.setLocNo(locDetl.getLocNo());
                        adjDetl.setMatnr(locDetl.getMatnr());
                        adjDetl.setBatch(locDetl.getBatch());
                        adjDetl.setOriQty(locDetl.getAnfme());
                        adjDetl.setAdjQty(adjust.getCount());
                        adjDetl.setModiTime(now);
                        adjDetl.setModiUser(userId);
                        adjDetl.setAppeTime(now);
                        adjDetl.setAppeUser(userId);
                        adjDetlService.save(adjDetl, userId);
                    }
                    iterator.remove();
                    iterator1.remove();
                }
            }
        }

        // 删除库存
        for (LocDetl locDetl : locDetls) {
            // todo 盘点记录
            if (!locDetlService.updateAnfme(-1.0D, locDetl.getLocNo(), locDetl.getMatnr(), locDetl.getBatch())) {
                throw new CoolException("删除" + locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "批号库存明细失败");
            }
            // 保存调整记录
            AdjDetl adjDetl = new AdjDetl();
            adjDetl.setLocNo(locDetl.getLocNo());
            adjDetl.setMatnr(locDetl.getMatnr());
            adjDetl.setBatch(locDetl.getBatch());
            adjDetl.setOriQty(locDetl.getAnfme());
            adjDetl.setAdjQty(0.0D);
            adjDetl.setModiTime(now);
            adjDetl.setModiUser(userId);
            adjDetl.setAppeTime(now);
            adjDetl.setAppeUser(userId);
            adjDetlService.save(adjDetl, userId);
        }

        // 添加库存
        for (LocDetlAdjustParam.LocDetlAdjust adjust : list) {
            if (adjust.getCount() == 0.0D) { continue; }
            Mat mat = matService.selectByMatnr(adjust.getMatnr());
            LocDetl locDetl = new LocDetl();
            locDetl.sync(mat);
            locDetl.setBatch(adjust.getBatch());
            locDetl.setLocNo(locMast.getLocNo());
            locDetl.setAnfme(adjust.getCount()); // 数量
            locDetl.setModiUser(userId); // 操作人员信息
            locDetl.setModiTime(now);
            locDetl.setAppeUser(userId);
            locDetl.setAppeTime(now);
            if (!locDetlService.insert(locDetl)) {
                throw new CoolException("添加" + locDetl.getLocNo() + "库位，" + locDetl.getMatnr() + "商品，" + locDetl.getBatch() + "批号库存明细失败");
            }
            // 保存调整记录
            AdjDetl adjDetl = new AdjDetl();
            adjDetl.setLocNo(locMast.getLocNo());
            adjDetl.setMatnr(adjust.getMatnr());
            adjDetl.setBatch(adjust.getBatch());
            adjDetl.setOriQty(0.0D);
            adjDetl.setAdjQty(adjust.getCount());
            adjDetl.setModiTime(now);
            adjDetl.setModiUser(userId);
            adjDetl.setAppeTime(now);
            adjDetl.setAppeUser(userId);
            adjDetlService.save(adjDetl, userId);
        }
        // 修改库位状态
        int count = locDetlService.selectCount(new EntityWrapper<LocDetl>().eq("loc_no", locMast.getLocNo()));
        if (locMast.getLocSts().equals("F")) {
            if (count == 0) {
                locMast.setLocSts("D");
            }
        }
        if (locMast.getLocSts().equals("D") || locMast.getLocSts().equals("O")) {
            if (count > 0) {
                locMast.setLocSts("F");
            }
        }
        locMast.setModiUser(userId);
        locMast.setModiTime(now);
        if (!locMastService.updateById(locMast)) {
            throw new CoolException("更新库位状态失败");
        }
    }


    @Override
    @Transactional
    public void cancelWrkMast(String workNo, Long userId) {
        Date now = new Date();
        WrkMast wrkMast = wrkMastService.selectById(workNo);
        if (Cools.isEmpty(wrkMast)){
            throw new CoolException(workNo+"工作档不存在");
        }
        String locNo = ""; // 待修改目标库位
        String locSts = ""; // 待修改目标库位状态
        // 入库取消（修改目标库位）
        if (wrkMast.getIoType() < 100) {
            locNo = wrkMast.getLocNo();
            locSts = "O";

            // 库位转移
            if (wrkMast.getIoType() == 11) {
                // 库位转移：源库位
                LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException("取消库位转移失败，源库位不存在:"+ wrkMast.getSourceLocNo());
                }
                locMast.setLocSts(wrkMast.getFullPlt().equalsIgnoreCase("N")?"D":"F");
                locMast.setModiTime(now);
                locMast.setModiUser(userId);
                locMastService.updateById(locMast);
            }
        // 出库取消（修改源库位）
        } else if (wrkMast.getIoType() > 100 && wrkMast.getWrkSts() != 14) {
            locNo = wrkMast.getSourceLocNo();
            // 出库 ===>> F.在库
            if (wrkMast.getIoType() == 101 || wrkMast.getIoType() == 103 || wrkMast.getIoType() == 107) {
                locSts = "F";
            // 空板出库 ===>> D.空桶/空栈板
            } else if (wrkMast.getIoType() == 110) {
                locSts = "D";
            // 库位转移 ===>> D.空桶/空栈板
            } else if (wrkMast.getIoType() == 11) {
                locSts = wrkMast.getFullPlt().equalsIgnoreCase("N")?"D":"F";
                // 库位转移：目标库位
                LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
                if (Cools.isEmpty(locMast)) {
                    throw new CoolException("取消库位转移失败，目标库位不存在:"+ wrkMast.getSourceLocNo());
                }
                locMast.setLocSts("O");
                locMast.setModiTime(now);
                locMast.setModiUser(userId);
                locMastService.updateById(locMast);
            }
        } else {
            throw new CoolException("当前工作状态无法取消");
        }

        //取消入库工作档时，查询组托表，如果有将状态改为待处理
        if(wrkMast.getIoType() == 1) {
            List<WaitPakin> waitPakins=waitPakinService.selectList(new EntityWrapper<WaitPakin>().eq("zpallet", wrkMast.getBarcode()));
            for (WaitPakin waitPakin:waitPakins){
                if (!Cools.isEmpty(waitPakin)) {
                    waitPakin.setIoStatus("N");
                    waitPakin.setLocNo("");
                    waitPakinService.update(waitPakin, new EntityWrapper<WaitPakin>()
//                            .eq("order_no", waitPakin.getOrderNo())
                            .eq("zpallet",waitPakin.getZpallet())
                            .eq("matnr", waitPakin.getMatnr()));
                }
            }
        }

        //取消出库工作档时，查询单据管理表，回滚作业中数量
        if(wrkMast.getIoType() == 101 || wrkMast.getIoType() == 103) {
            List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
            for (WrkDetl wrkDetl : wrkDetls) {
                if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
                    if (!orderDetlService.decrease(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch(), wrkDetl.getAnfme())) {
                        throw new CoolException("订单数据回滚失败");
                    }

                    //修改订单主表状态,没有作业数量时才可以修改
                    boolean flag = true;
                    List<OrderDetl> orderDetls = orderDetlService.selectList(new EntityWrapper<OrderDetl>().eq("order_no",wrkDetl.getOrderNo()));
                    for(OrderDetl orderDetl : orderDetls){
                        if(orderDetl.getWorkQty() > 0){
                            flag = false;
                        }
                    }
                    if(flag){
                        Order order = orderService.selectOne(new EntityWrapper<Order>().eq("order_no",wrkDetl.getOrderNo()));
                        if(!Cools.isEmpty(order) && order.getSettle()==2){
                            order.setSettle(1L);
                            order.setUpdateBy(userId);
                            order.setUpdateTime(now);
                        }
                        if(!orderService.update(order,new EntityWrapper<Order>().eq("order_no",wrkDetl.getOrderNo()))){
                            throw new CoolException("修改订单状态失败");
                        }
                    }
                }
            }

        }

//        // 订单关联
//        List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());
//        for (WrkDetl wrkDetl : wrkDetls) {
//            if (!Cools.isEmpty(wrkDetl.getOrderNo())) {
//                if (!orderDetlService.decrease(wrkDetl.getOrderNo(), wrkDetl.getMatnr(), wrkDetl.getBatch(), wrkDetl.getAnfme())) {
//                    throw new CoolException("订单数据回滚失败");
//                }
//                // 生成新的出库作业
////                        stockOutRe(wrkMast, wrkDetls);
//            }
//        }

        // 取消操作人员记录
        wrkMast.setManuType("手动取消");
        wrkMast.setModiUser(userId);
        wrkMast.setModiTime(now);
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("取消工作档失败");
        }
        // 保存工作主档历史档
        if (!wrkMastLogService.save(wrkMast.getWrkNo())) {
            throw new CoolException("保存工作历史档失败, workNo = " + wrkMast.getWrkNo());
        }
        // 删除工作主档
        boolean wrkMastRes = wrkMastService.deleteById(wrkMast);

        if (wrkMast.getIoType() != 10 && wrkMast.getIoType() != 110) {
            // 保存工作明细档历史档
            if (!wrkDetlLogService.save(wrkMast.getWrkNo())) {
//                throw new CoolException("保存工作明细历史档失败, workNo = " + wrkMast.getWrkNo());
            }
            // 删除工作档明细
            boolean wrkDetlRes = wrkDetlService.delete(new EntityWrapper<WrkDetl>().eq("wrk_no", workNo));
        }

        // 修改库位状态
        LocMast locMast = locMastService.selectById(locNo);
        if (Cools.isEmpty(locMast)) {
            throw new CoolException("取消工作档失败，库位不存在:"+ locNo);
        }
        locMast.setLocSts(locSts);
        locMast.setModiTime(now);
        locMast.setModiUser(userId);
        boolean locMastRes = locMastService.updateById(locMast);
        if (!wrkMastRes || !locMastRes) {
            throw new CoolException("保存数据失败");
        }

        //wms取消任务 同时调用wcs任务取消接口通知wcs
        WrkCancel wrkCancel = new WrkCancel();
        Date date = new Date();
        DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        wrkCancel.setTaskId(workNo); // 任务号
        wrkCancel.setMsgTime(dateFormat.format(date)); // 取消时间
        wrkCancel.setWarehouse(warehouse); // 仓库编码

        String response = "";
        boolean flag = false;
        try {
            response = new HttpHandler.Builder()
                    .setUri(url)
                    .setPath(cancel)
                    .setJson(JSON.toJSONString(wrkCancel))
                    .build()
                    .doPost();
            JSONObject jsonObject = JSON.parseObject(response);
            if (jsonObject.getInteger("returnStatus") == 0){
                flag = true;
            }else {
                log.error("wms取消任务下发wcs失败--->url：{}；request：{}；response：{}", url+"/"+cancel, JSON.toJSONString(wrkCancel), response);
                throw new CoolException("wms取消任务下发wcs失败");
            }
        }catch (Exception e){
            log.error("fail", e);
        }finally {
            try {
                //保存接口日志
                apiLogService.save(
                        "wms下发任务给wcs",
                        url+"/"+cancel,
                        null,
                        "127.0.0.1",
                        JSON.toJSONString(wrkCancel),
                        response,
                        flag
                );
            }catch (Exception e){
                log.error("",e);
            }
        }


    }

    @Override
    @Transactional
    public void pickWrkMast(String workNo, Long userId) {
        WrkMast wrkMast = wrkMastService.selectById(workNo);
        if (Cools.isEmpty(wrkMast)){
            throw new CoolException(workNo+"工作档不存在");
        }
        // 入出库类型判断
        if (wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107) {
            throw new CoolException("当前入出库类型无法进行操作");
        }
        // 工作状态判断
        if (wrkMast.getWrkSts() < 11 || wrkMast.getWrkSts() == 15) {
            throw new CoolException("当前工作状态无法进行操作");
        }
        // 保存工作明细档历史档
//        if (!wrkDetlLogService.save(wrkMast.getWrkNo())) {
//            throw new CoolException("保存工作明细档历史档失败");
//        }
        // 保存工作主档历史档
        if (!wrkMastLogService.save(wrkMast.getWrkNo())) {
            throw new CoolException("保存工作主档历史档失败");
        }
        // 获取目标站
        Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                .eq("type_no", wrkMast.getIoType() - 50)
                .eq("stn_no", wrkMast.getStaNo()) // 作业站点 = 拣料出库的目标站
                .eq("crn_no", wrkMast.getCrnNo()); // 堆垛机号
        StaDesc staDesc = staDescService.selectOne(wrapper);
        if (Cools.isEmpty(staDesc)) {
            throw new CoolException("入库路径不存在");
        }
        Date now = new Date();
        // 堆垛机站点(目标站)
        Integer staNo = staDesc.getCrnStn();
        // 更新工作档数据状态
        wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
        wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
        wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
        wrkMast.setStaNo(staNo); // 目标站
        wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
        wrkMast.setSourceLocNo(""); // 源库位清空
        wrkMast.setModiTime(now);
        wrkMast.setModiUser(userId);
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("更新工作档数据状态失败");
        }
        // 修改库位状态 Q.拣料/盘点/并板再入库
        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
        locMast.setLocSts("Q");
        locMast.setModiTime(now);
        locMast.setModiUser(userId);
        if (!locMastService.updateById(locMast)) {
            throw new CoolException("修改库位状态失败");
        }
    }

    @Override
    public StartupDto createWaitPainWrkMastStart(List<WaitPakin> list, Long userId) {
        if (Cools.isEmpty(list)) {
            throw new CoolException("入库通知档不能为空");
        }
        LocTypeDto locTypeDto = new LocTypeDto();
        locTypeDto.setLocType1((short) 1);
        return wcsController.startupFullPutStore(301, list.get(0).getZpallet(), locTypeDto, list);
    }

    @Override
    @Transactional
    public String dealPreHaveStart(Integer wrkNo, Long userId) {
        WrkMast wrkMast = wrkMastService.selectById(wrkNo);
        if (wrkMast == null) {
            throw new CoolException("任务已失效");
        }
        String locNo = wrkMast.getLocNo();
        LocMast locMast = locMastService.selectById(locNo);
        assert locMast != null;
        RowLastno rowLastno = rowLastnoService.findBySection(locMast.getRow1());
        assert rowLastno != null;

        // 目标库位
        LocMast targetLoc = null;

        for (int curRow = rowLastno.getsRow(); curRow<=rowLastno.geteRow(); curRow++) {

            if (Utils.isShallowLoc(slaveProperties, curRow)) {
                Integer deepRow = Utils.getDeepRow(slaveProperties, curRow);
                targetLoc = locMastService.queryFreeLocMast(deepRow, locMast.getLocType1());
                // 因库位移转、需预留空库位
                if (!locMastService.checkEmptyCount(targetLoc)) {
                    continue;
                }
            }
            if (Cools.isEmpty(targetLoc)) {
                targetLoc = locMastService.queryFreeLocMast(curRow, locMast.getLocType1());
                // 因库位移转、需预留空库位
                if (!locMastService.checkEmptyCount(targetLoc)) {
                    continue;
                }
                // 目标库位 ===>> 浅库位， 则校验其深库位是否为 F D X
                if (null != targetLoc && Utils.isShallowLoc(slaveProperties, targetLoc.getLocNo())) {
                    LocMast deepLoc = locMastService.selectById(Utils.getDeepLoc(slaveProperties, targetLoc.getLocNo()));
                    if (!deepLoc.getLocSts().equals("F") && !deepLoc.getLocSts().equals("D") && !deepLoc.getLocSts().equals("X")) {
                        continue;
                    }
                }
                // 目标库位 ===>> 深库位， 则校验其浅库位是否为 O
                if (null != targetLoc && Utils.isDeepLoc(slaveProperties, targetLoc.getLocNo())) {
                    LocMast shallowLoc = locMastService.selectById(Utils.getShallowLoc(slaveProperties, targetLoc.getLocNo()));
                    if (!shallowLoc.getLocSts().equals("O")) {
                        continue;
                    }
                }
            }

            if (!Cools.isEmpty(targetLoc)) {
                break;
            }

        }

        if (targetLoc == null) {
            throw new CoolException("操作失败，当前仓库找不到空库位");
        }

        Date now = new Date();
        // 修改工作档
        StaDesc staDesc = staDescService.queryCrnStn(targetLoc.getCrnNo());
        if (Cools.isEmpty(staDesc)) {
            throw new CoolException("入库路径不存在");
        }
        wrkMast.setWrkSts(2L);
        wrkMast.setLocNo(targetLoc.getLocNo());
        wrkMast.setStaNo(staDesc.getCrnStn());
        wrkMast.setCrnNo(targetLoc.getCrnNo());
        wrkMast.setModiTime(now);
        wrkMast.setModiUser(userId);
        wrkMast.setPreHave("N");
        if (!wrkMastService.updateById(wrkMast)) {
            throw new CoolException("修改工作档失败");
        }
        // 修改库位状态 O ===>>> S
        if (targetLoc.getLocSts().equals("O")){
            targetLoc.setLocSts("S"); // S.入库预约
            targetLoc.setModiUser(userId);
            targetLoc.setModiTime(now);
            if (!locMastService.updateById(targetLoc)){
                throw new CoolException("改变库位状态失败");
            }
        } else {
            throw new CoolException(targetLoc.getLocNo()+"目标库位已被占用");
        }
        // 禁用异常库位
//        locMast.setLocSts("X"); // X.禁用
//        locMast.setModiUser(userId);
//        locMast.setModiTime(now);
//        if (!locMastService.updateById(locMast)){
//            throw new CoolException("改变库位状态失败");
//        }
        return targetLoc.getLocNo();
    }

    @Override
    @Transactional
    public void turnMatLocDetl(EmptyPlateOutParam param, Long userId) {
        Mat mat = matService.selectOne(new EntityWrapper<Mat>().eq("id", param.getMatId()));
        if (Cools.isEmpty(mat)){
            throw new CoolException("目标库位商品编码有误！");
        }
        List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("matnr", param.getLocDetls().get(0).getMatnr()));
        if (Cools.isEmpty(locDetls) || locDetls.size()<1){
            throw new CoolException("待修改商品无库存，无需修改！  品号："+param.getLocDetls().get(0).getMatnr());
        }
        try {
            locDetlService.updateMatTurn(param.getLocDetls().get(0).getMatnr(),mat.getMatnr());
        }catch (Exception e){
            throw new CoolException("对数据库修改出错！");
        }
        for (LocDetl locDetl:locDetls){
            // 保存调整记录
            AdjDetl adjDetl = new AdjDetl();
            adjDetl.setLocNo(locDetl.getLocNo());
            adjDetl.setMatnr(mat.getMatnr());
            adjDetl.setMatnrOld(param.getLocDetls().get(0).getMatnr());
            adjDetl.setAdjQty(locDetl.getAnfme());
            adjDetlService.save(adjDetl, userId);
        }
    }

}