package com.mes.job;

import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.base.entity.BigStorageCageBaseInfo;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.entity.BigStorageDTO;
import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.service.BigStorageCageFeedTaskService;
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.device.PlcParameterObject;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.tools.S7control;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

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

/**
 * @author SNG-015
 */
@Component
@Slf4j
public class PlcStorageCageTask {

    @Resource
    private BigStorageCageService bigStorageCageService;
    @Resource
    private BigStorageCageDetailsService bigStorageCageDetailsService;
    @Resource
    private GlassInfoService glassInfoService;
    @Resource
    private BigStorageCageFeedTaskService bigStorageCageFeedTaskService;
    @Resource
    private BigStorageCageOutTaskService bigStorageCageOutTaskService;
    @Resource
    private EdgGlassTaskInfoService edgGlassTaskInfoService;
    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;

    private static final String REQUEST_WORD = "1";

    @Value("${mes.sequence.order}")
    private boolean sequenceOrder;

    @Value("${mes.carWidth}")
    private Integer carWidth;

    @Value("${mes.slotWidth}")
    private Integer slotWidth;

    @Value("${mes.inCarMaxSize}")
    private Integer inCarMaxSize;

    @Value("${mes.outCarMaxSize}")
    private Integer outCarMaxSize;

    @Value("${mes.galssGap}")
    private Integer galssGap;

    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgScan() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue();
        String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue();
        //D02id判断是否为空  确认是否空闲 允许进片
        String d02State = plcParameterObject.getPlcParameter("D02ID").getValue();
        String d03State = plcParameterObject.getPlcParameter("D03State").getValue();
        String d05State = plcParameterObject.getPlcParameter("D05State").getValue();
        String mesD01Address = plcParameterObject.getPlcParameter("MESToD01").getAddress();
        String mesD04Address = plcParameterObject.getPlcParameter("MESToD04").getAddress();
        String d01ToMES = plcParameterObject.getPlcParameter("D01ToMES").getValue();
        if (!REQUEST_WORD.equals(d01ToMES)) {
            log.info("请求字为{}，结束本次扫描进卧转立任务", d01ToMES);
            return;
        }

        log.info("1、获取d01Id扫描ID为：{};获取d04Id扫描ID为：{};", d01Id, d04Id);
        if (StringUtils.isBlank(d01Id) && StringUtils.isBlank(d04Id)) {
            log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
            return;
        }
        if (REQUEST_WORD.equals(d03State) && REQUEST_WORD.equals(d05State)) {
            log.info("两条线卧转立均在执行任务，结束本次扫描进卧转立任务");
            return;
        }
//        Boolean flag01 = Boolean.FALSE;
//        Boolean flag04 = Boolean.FALSE;
        //按照线路及玻璃id获取相邻两块玻璃 卧转立上的玻璃
        if (StringUtils.isNotBlank(d01Id) && (StringUtils.isBlank(d02State) || !REQUEST_WORD.equals(d03State))) {
            judgeGlassTypeStatus(d01Id, Const.A09_OUT_TARGET_POSITION, mesD01Address);
        }
        if (StringUtils.isNotBlank(d04Id) && !REQUEST_WORD.equals(d05State)) {
            judgeGlassTypeStatus(d04Id, Const.A10_OUT_TARGET_POSITION, mesD04Address);
        }
        log.info("结束扫码任务");
//        if (flag01 && flag04) {
//            //比较最早一片任务的版图id及版序 求出卧转立的线路
//            Integer startLine = getStartLine();
//            //计算目标格子，发送启动任务
//            computeTargetByLine(startLine);
//        } else if (flag01 || flag04) {
//            Integer startLine = flag01.equals(Boolean.TRUE) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
//            //计算目标格子，发送启动任务
//            computeTargetByLine(startLine);
//        } else {
//            log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
//        }
    }

    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgFreeCarTask() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String e01Status = plcParameterObject.getPlcParameter("E01State").getValue();
        String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue();
        String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue();
        log.info("执行空车送片任务，获取到的大车状态为{}，卧转立状态分别为d03:{}，d05:{}", e01Status, d03ToMES, d05ToMES);
        if (REQUEST_WORD.equals(e01Status)) {
            log.info("进片大车非空闲，结束送片任务");
            return;
        }
        if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) {
            log.info("卧转立没有送片请求，结束送片任务");
            return;
        }
        LambdaQueryWrapper<BigStorageCageFeedTask> wrapper = new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .eq(BigStorageCageFeedTask::getTaskType, Const.BIG_STORAGE_IN_RUN)
                .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP);
        //获取可以启动卧转立的任务线路
        List<BigStorageCageFeedTask> feedTaskList = bigStorageCageFeedTaskService.list(wrapper);
        if (CollectionUtils.isNotEmpty(feedTaskList)) {
            if (feedTaskList.size() == 1) {
                computeTargetByLine(feedTaskList.get(0).getLine());
                return;
            } else {
                //比较最早一片任务的版图id及版序 求出卧转立的线路
                Integer startLine = getStartLine();
//            //计算目标格子，发送启动任务
                computeTargetByLine(startLine);
                return;
            }
        }
        String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue();
        String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue();
        log.info("1、获取d01Id扫描ID为：{};获取d04Id扫描ID为：{};", d01Id, d04Id);
        //两条线都有进卧转立任务，直接结束
//        if (StringUtils.isNotBlank(d01Id) && StringUtils.isNotBlank(d04Id)) {
//            log.info("两条线都存在进片任务，结束任务");
//            return;
//        }
        //获取两条线卧转立是否有玻璃，且任务状态都为2
        List<Integer> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
        if (CollectionUtils.isEmpty(lineList)) {
            log.info("两条线卧转立为空或者有进片任务未完成，结束任务");
            return;
        }
        Integer lineFirst = lineList.get(0);
        String lineGlassId = lineFirst.equals(Const.A09_OUT_TARGET_POSITION) ? d01Id : d04Id;
        //仅有一条先符合启动启动条件
        if (lineList.size() == 1) {
            //如果进片请求但玻璃为空，计算任务表进片格子 发送进片任务
            if (StringUtils.isEmpty(lineGlassId)) {
                computeTargetByLine(lineFirst);
            } else {
                //todo:计算扫描到的玻璃是否可以存进卧转立
                //获取卧转立剩余宽度
                if (computeIsRun(lineFirst, lineGlassId)) {
                    computeTargetByLine(lineFirst);
                }
            }
            return;
        }
        //两条先均可执行进片任务，判断两条线是否进片请求是否都为空
        if (StringUtils.isBlank(d01Id) && StringUtils.isBlank(d04Id)) {
            //比较最早一片任务的版图id及版序 求出卧转立的线路
            Integer line = getStartLine();
            //计算任务表进片格子 发送进片任务
            computeTargetByLine(line);
            return;
        } else if (StringUtils.isNotBlank(d01Id) && StringUtils.isNotBlank(d04Id)) {
//            todo:两个都有进片玻璃
            if (computeIsRun(Const.A09_OUT_TARGET_POSITION, d01Id) && computeIsRun(Const.A10_OUT_TARGET_POSITION, d04Id)) {
                //比较最早一片任务的版图id及版序 求出卧转立的线路
                Integer line = getStartLine();
                //计算任务表进片格子 发送进片任务
                computeTargetByLine(line);
            } else if (computeIsRun(Const.A09_OUT_TARGET_POSITION, d01Id)) {
                computeTargetByLine(Const.A09_OUT_TARGET_POSITION);
            } else if (computeIsRun(Const.A10_OUT_TARGET_POSITION, d04Id)) {
                computeTargetByLine(Const.A10_OUT_TARGET_POSITION);
            } else {
                return;
            }
        } else {
            //，或者仅有一条有玻璃
            //一条线为空，一条线有进片请求有玻璃
            int outLine = StringUtils.isBlank(d01Id) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
            //获取进片请求玻璃为空的，计算任务表进片格子 发送进片任务
            computeTargetByLine(outLine);
        }

    }

    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgOutTask() {

        List<BigStorageCageOutTask> outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>().eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW));
        Assert.isTrue(CollectionUtils.isEmpty(outingList), "有正在执行出片的任务，结束当前出片线程");

        //是否有正在钢化的玻璃
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
                .selectAll(TemperingGlassInfo.class)
                .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                .isNull(BigStorageCageOutTask::getGlassId)
                .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
        if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
            log.info("有正在出片的钢化任务");
            computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE);
            return;
        }
        //是否有人工下片任务   有直接出
        List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));
        if (CollectionUtils.isNotEmpty(artificialList)) {
            computeOutGlassInfo(temperingGlassInfoList, Boolean.FALSE);
            return;
        }
        //钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
        TemperingLayoutDTO temperingLayoutDTO = bigStorageCageDetailsService.temperingIsAll();
        if (null != temperingLayoutDTO) {
            //玻璃到齐
            //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务  结束
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                    .selectAll(GlassInfo.class)
                    .select("-1 as state")
                    .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                    .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .eq(GlassInfo::getTemperingLayoutId, temperingLayoutDTO.getTemperingLayoutId())
                    .eq(GlassInfo::getEngineerId, temperingLayoutDTO.getEngineerId()));
            temperingGlassInfoService.saveBatch(temperingGlassInfos);
            computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE);
            return;
        }
        //未到齐 执行内部调度任务
        TemperingLayoutDTO temperingOccupySlot = bigStorageCageDetailsService.queryTemperingOccupySlot();
        if (null != temperingOccupySlot) {
            List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
            for (int i = 0; i < slotSequenceList.size() - 1; i++) {
                SlotSequenceDTO first = slotSequenceList.get(i);
                SlotSequenceDTO second = slotSequenceList.get(i + 1);
                int slotWidth = carWidth - first.getRemainWidth() - galssGap;
                if (first.getMinSequence() == second.getMaxSequence() + 1
                        && second.getRemainWidth() > slotWidth) {
                    List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                            .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN));
                    List<BigStorageCageOutTask> outTasks = list.stream().map(e -> new BigStorageCageOutTask(e.getGlassId(), first.getSlot(), second.getSlot(),
                            slotWidth, 0, 0, 1)).collect(Collectors.toList());
                    bigStorageCageOutTaskService.saveBatch(outTasks);
                    return;
                }
            }
        }
    }


    /**
     * 按照玻璃id判断玻璃状态及卧转立是否可直接启动
     */
    public Boolean judgeGlassTypeStatus(String glassId, Integer line, String mesAddress) {
        //1、获取任务表中相邻玻璃
        List<EdgGlassTaskInfo> edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>()
                .eq(EdgGlassTaskInfo::getLine, line)
                .apply("time >= (select time from edg_glass_task_info where glass_id = '" + glassId + "')")
                .orderByAsc(EdgGlassTaskInfo::getTime));
        Assert.isFalse(CollectionUtils.isEmpty(edgGlassTaskInfoList), "识别玻璃信息未出现在尺寸表中,获取相邻两块玻璃失败");
        //2、获取卧转立剩余宽度
        BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line);
        Integer remainWidth;
        Integer glassCount;
        if (0 == sitToUpRemainWidth.getGlassCount()) {
            remainWidth = carWidth;
            glassCount = 0;
        } else {
            remainWidth = sitToUpRemainWidth.getWidth();
            glassCount = sitToUpRemainWidth.getGlassCount();
        }

        Boolean flag = Boolean.TRUE;
        //2、获取卧转立
        Integer widthFirst = edgGlassTaskInfoList.get(0).getWidth();
        if (edgGlassTaskInfoList.size() == 1) {
            if (remainWidth >= widthFirst) {
                if (glassCount <= 5) {
                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst);
                } else {
                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst);
                }
            } else {
                flag = Boolean.FALSE;
            }
        } else {
            Integer widthSecond = edgGlassTaskInfoList.get(1).getWidth();
            if (remainWidth >= widthFirst) {
                if (remainWidth - widthFirst - galssGap >= widthSecond) {
                    if (glassCount <= inCarMaxSize - 1) {
                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst);
                    } else {
                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst);
                    }
                } else {
                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst);
                }
            } else {
                flag = Boolean.FALSE;
            }
        }
        //向plc发送进片确认
        if (flag) {
            S7object.getinstance().plccontrol.writeWord(mesAddress, 1);
        }
        //记录无法放下玻璃，后续判断启动
        return flag;
    }

    /**
     * 添加任务信息
     */
    private Boolean addFeedTask(String glassId, Integer line, Integer taskType, Integer width) {
        BigStorageCageFeedTask bigStorageCageFeedTask = new BigStorageCageFeedTask();
        bigStorageCageFeedTask.setGlassId(glassId);
        bigStorageCageFeedTask.setTaskState(Const.BIG_STORAGE_IN_NEW);
        bigStorageCageFeedTask.setLine(line);
        bigStorageCageFeedTask.setTaskType(taskType);
        bigStorageCageFeedTask.setWidth(width);
        bigStorageCageFeedTask.setCreateTime(new Date());
        return bigStorageCageFeedTaskService.save(bigStorageCageFeedTask);
    }

    /**
     * 获取需要启动的线路：两条线都可启动 获取第一片玻璃版图id最小 版序最大的线路
     *
     * @return 需要启动的线路
     */
    public Integer getStartLine() {
        List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .inSql(BigStorageCageFeedTask::getId, "select min(id) from big_storage_cage_feed_task where task_state = 2 group by line"));
        Assert.isFalse(CollectionUtils.isEmpty(taskList), "卧转立两条线都没有玻璃进片任务");
        Map<String, Integer> taskMap = taskList.stream().collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId,
                BigStorageCageFeedTask::getLine));
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                .in(GlassInfo::getGlassId, taskMap.keySet())
                .orderByAsc(GlassInfo::getTemperingLayoutId)
                .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
                .last("limit 1"));
        return taskMap.get(glassInfo.getGlassId());
    }

    /**
     * 计算任务表进片线路的目标格子，并启动任务
     */
    public boolean computeTargetByLine(Integer line) {
        //1、获取任务表中的所有玻璃（指定线路且已经进卧转立完成）
        List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .eq(BigStorageCageFeedTask::getLine, line)
                .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP_ALL)
                .orderByAsc(BigStorageCageFeedTask::getId));
        //2、去笼子内查找是否可以继续存放的笼子
        List<String> glassIds = taskList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList());
        List<GlassInfo> glassInfos = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIds));
        return computeIsTemperingTargetByLine(glassInfos, taskList, line);
    }

    /**
     * 是否钢化玻璃进笼目标位置
     *
     * @param glassInfos 当条线卧转立所有玻璃
     * @param taskList   当条线卧转立所有任务
     * @param line       任务是哪条线
     */
    private boolean computeIsTemperingTargetByLine(List<GlassInfo> glassInfos, List<BigStorageCageFeedTask> taskList, Integer line) {
        //1、将玻璃信息集合转为glassid为key的map
        Map<String, GlassInfo> glassInfoMap = glassInfos.stream()
                .collect(Collectors.toMap(GlassInfo::getGlassId, p -> p));
        for (BigStorageCageFeedTask e : taskList) {
            GlassInfo info = glassInfoMap.get(e.getGlassId());
            if (info == null) {
                continue;
            }
            BigStorageCageDetails cageDetails = new BigStorageCageDetails();
            BeanUtils.copyProperties(info, cageDetails);
            //2、获取目标格子信息
            BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info);
            //3、更新大理片笼表剩余宽度
            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - info.getWidth())
                    .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot()));
            //4、更新进片任务表，目标格子及状态（状态改为2 电气扫到自行处理）  遇到问题：无法批量更新，批量更新无法走指定从库
            e.setTargetSlot(bigStorageDTO.getSlot());
//            e.setTaskType(Const.BIG_STORAGE_IN_RUN);
            bigStorageCageFeedTaskService.updateById(e);

            //5、将进片信息存入大理片笼详情表
            cageDetails.setSlot(bigStorageDTO.getSlot());
            cageDetails.setState(Const.GLASS_STATE_IN);
            bigStorageCageDetailsService.save(cageDetails);
        }
        sendTaskListToPLC(taskList, line);
        return Boolean.TRUE;
    }

    private void sendTaskListToPLC(List<BigStorageCageFeedTask> taskList, Integer line) {
        S7control s7control = S7object.getinstance().plccontrol;
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        String mesD03Address = plcMesObject.getPlcParameter("MESToD03").getAddress();
        String mesD05Address = plcMesObject.getPlcParameter("MESToD05").getAddress();
        String outLine = line.equals(Const.A09_OUT_TARGET_POSITION) ? mesD03Address : mesD05Address;
        for (int i = 1; i <= taskList.size(); i++) {
            s7control.writeWord(plcMesObject.getPlcParameter("StartAddToImport" + i).getAddress(), taskList.get(i - 1).getLine());
            s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot());
        }
        s7control.writeWord(outLine, 2);
        log.info("送片任务已发送完成，任务线路为：{}，启动地址为{}", line, outLine);
    }

    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, Boolean isTempering) {
        //任务数据  获取车子存放玻璃最大数量  玻璃间隔
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        //打车剩余尺寸
        Integer remainWidth = carWidth;
        for (T e : list) {
            if (bigStorageCageOutTaskList.size() > outCarMaxSize || e.getWidth() > remainWidth) {
                break;
            }
            remainWidth = remainWidth - (int) e.getWidth() - galssGap;
            if (isTempering) {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                        (int) e.getWidth() * 10, 0, 0, 1));
            } else {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        (int) e.getWidth() * 10, 0, 0, 1));
            }

        }
        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
        bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
        List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
        log.info("将出片玻璃{}玻璃状态改为已出片", glassIds);
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        //更新笼子内格子的剩余尺寸
        updateSlotRemain(list, glassIds);
        return Boolean.TRUE;
    }

    /**
     * 更新笼子内格子的剩余尺寸
     *
     * @param list
     * @param taskGlassIds
     * @param <T>
     */
    public <T extends BigStorageCageBaseInfo> void updateSlotRemain(List<T> list, List<String> taskGlassIds) {
        //获取需要出去（包括待出去的）的所有玻璃格子号
        List<Integer> slotList = list.stream().map(T::getSlot).distinct().collect(Collectors.toList());
        //获取待出去的玻璃信息（等下车出去的玻璃）
        Map<Integer, Double> slotRemainMap = list.stream().filter(e -> !taskGlassIds.contains(e.getGlassId()))
                .collect(Collectors.groupingBy(T::getSlot, Collectors.summingDouble(item -> item.getWidth() + galssGap)));
        if (CollectionUtils.isNotEmpty(slotRemainMap)) {
            //按照格子号更新剩余尺寸
            slotRemainMap.forEach((e, v) -> {
                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth - v)
                        .eq(BigStorageCage::getSlot, e));
            });
        }
        Set<Integer> remainSlotList = slotRemainMap.keySet();
        slotList.removeAll(remainSlotList);
        if (CollectionUtils.isNotEmpty(slotList)) {
            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth)
                    .in(BigStorageCage::getSlot, slotList));
        }
    }

    public Boolean computeIsRun(int line, String glassId) {
        //获取卧转立剩余宽度
        BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line);
        //获取玻璃信息
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
        return sitToUpRemainWidth.getWidth() < glassInfo.getWidth();
    }

}