package com.mes.job;

import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.entity.BigStorageDTO;
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 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.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;
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;

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

    public static boolean bigStorageCageFullAlarm = false;

    private int line1Time = 0;
    private int line2Time = 0;

    /**
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
     * fixedDelay : 上一个调用结束后再次调用的延时
     */
//    @Scheduled(fixedDelay = 5000)
//    public void plcStorageCageTask() throws InterruptedException {
//
//        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
//        try {
//
//            String plcFeedGlassid = "";
//            String plcFeedReqLine = "0";
//            if ("1".equals(plcParameterObject.getPlcParameter("D01Request").getValue())) {
//                plcFeedReqLine = "1";
//                plcFeedGlassid = plcParameterObject.getPlcParameter("D01ID1").getValue();
//            }
//            if ("1".equals(plcParameterObject.getPlcParameter("D04Request").getValue())) {
//                plcFeedReqLine = "2";
//                plcFeedGlassid = plcParameterObject.getPlcParameter("D04ID1").getValue();
//            }
//            line1Time += 1;
//            line2Time += 1;
//
//            if (!("0".equals(plcFeedReqLine))) {
//                log.info("1、Plc进片请求时");
//                BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
//                GlassInfo glassInfo = glassInfoService.getById(plcFeedGlassid);
//                log.info("2、根据玻璃id获取玻璃信息" + glassInfo);
//                if (bigStorageCageDetailsService.selectGetBoard(plcFeedReqLine) >= 0) {
//                    BigStorageCageDetails slotInfo = bigStorageCageService.feedGlass(glassInfo, bigStorageCageDetails);
//                    if (slotInfo != null) {
//                        int taskType = edgGlassTaskInfoService.judgeTasktype(plcFeedReqLine);
//                        log.info("3、查询任务表判断当前任务类型为上车等到还是上车启动" + taskType);
//                        bigStorageCageFeedTaskService.addFeedTask(slotInfo, Integer.parseInt(plcFeedReqLine), taskType);
//                        log.info("4、添加任务到任务表");
//                        bigStorageCageFullAlarm = false;
//                    } else {
//                        bigStorageCageFullAlarm = true;
//                    }
//                } else {
//                    log.info("当前玻璃宽度不够上车" + glassInfo);
//                    if (!("1".equals(plcFeedReqLine))) {
//                        S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
//                    } else {
//                        S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
//                    }
//                }
//            } else {
//                List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskService.querybigStorageCageFeedTask(1);
//                log.info("5、查询任务表是否有已经完成的进片任务" + bigStorageCageFeedTaskList.size());
//                for (BigStorageCageFeedTask bigStorageCageFeedTask : bigStorageCageFeedTaskList
//                ) {
//                    BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
//                    bigStorageCageDetails.setId(bigStorageCageFeedTask.getId());
//                    bigStorageCageDetails.setState(1);
//                    bigStorageCageDetailsService.updateById(bigStorageCageDetails);
//                    log.info("6、修改理片笼详情玻璃状态");
//                    bigStorageCageFeedTaskService.removeById(bigStorageCageFeedTask);
//                    log.info("7、删除已经完成的进片任务");
//                }
//                //启动阈值
//                if (line1Time >= 300) {
//                    if ("0".equals(plcParameterObject.getPlcParameter("D05Go").getValue())) {
//                        S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
//                    }
//                }
//                if (line2Time >= 300) {
//                    if ("0".equals(plcParameterObject.getPlcParameter("D02Go").getValue())) {
//                        S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
//                    }
//                }
//            }
//
//            //查询出片表是否有任务未完成的任务
//            List<BigStorageCageOutTask> bigStorageCageOutTask = bigStorageCageOutTaskService.querybigStorageCageOutTask(0);
//            if (bigStorageCageOutTask.size() == 0) {
//                boolean result = bigStorageCageService.outGlass();
//                log.info("8、没有未完成任务时调用出片接口");
//                if (result == false) {
//                    temperingGlassInfoService.schedulingTask();
//                }
//            }
//            bigStorageCageOutTaskService.updateOutTask();
//            log.info("9、根据任务表状态修改钢化小片表任务状态");
//
//            //来不及送时直接走
//            String line = Integer.toString(edgGlassTaskInfoService.startTask());
//
//            if (!(line.equals(plcFeedReqLine))) {
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
//            } else {
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
//            }
//
//
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
    @Scheduled(fixedDelay = 5000)
    public void plcToHomeEdgScan() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String d01Request = plcParameterObject.getPlcParameter("D01Request").getValue();
        String d01ID1 = plcParameterObject.getPlcParameter("D01ID1").getValue();
        String d04Request = plcParameterObject.getPlcParameter("D04Request").getValue();
        String d04ID1 = plcParameterObject.getPlcParameter("D04ID1").getValue();
        log.info("1、获取到的请求字d01为：{}，获取到的扫描ID为：{};获取到的请求字d04为：{}，获取到的扫描ID为：{};",
                d01Request, d01ID1, d04Request, d04ID1);
        if (!"1".equals(d01Request) && !"1".equals(d04Request)) {
            log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
            return;
        }
        //        0：不干预 ； 1：条件满足情况下立即发车
        String d02GoAdress = plcParameterObject.getPlcParameter("D02Go").getAddress();
        //        0：不干预 ； 1：条件满足情况下立即发车
        String d05GoAdress = plcParameterObject.getPlcParameter("D05Go").getAddress();
        Boolean flag01 = Boolean.FALSE;
        Boolean flag04 = Boolean.FALSE;
        //按照线路及玻璃id获取相邻两块玻璃 卧转立上的玻璃
        if ("1".equals(d01Request)) {
            flag01 = judgeGlassTypeStatus(d01ID1, Const.A09_OUT_TARGET_POSITION);
        }
        if ("1".equals(d04Request)) {
            flag04 = judgeGlassTypeStatus(d04ID1, Const.A10_OUT_TARGET_POSITION);
        }
        if (flag01 && flag04) {
            //比较最早一片任务的版图id及版序 求出卧转立的线路
            Integer startLine = getStartLine();
            //计算目标格子，发送启动任务
            computeTargetByLine(startLine, d02GoAdress, d05GoAdress);
        } else if (flag01 || flag04) {
            Integer startLine = flag01.equals(Boolean.TRUE) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
            //计算目标格子，发送启动任务
            computeTargetByLine(startLine, d02GoAdress, d05GoAdress);
        } else {
            log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
        }
    }

    @Scheduled(fixedDelay = 5000)
    public void plcToHomeEdgFreeCarTask() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String freeCar = plcParameterObject.getPlcParameter("freeCar").getValue();
        if ("1".equals(freeCar)) {
            log.info("大车非空闲");
            return;
        }
        String d01Request = plcParameterObject.getPlcParameter("D01Request").getValue();
        String d01ID1 = plcParameterObject.getPlcParameter("D01ID1").getValue();
        String d04Request = plcParameterObject.getPlcParameter("D04Request").getValue();
        String d04ID1 = plcParameterObject.getPlcParameter("D04ID1").getValue();
        log.info("1、获取到的请求字d01为：{}，获取到的扫描ID为：{};获取到的请求字d04为：{}，获取到的扫描ID为：{};",
                d01Request, d01ID1, d04Request, d04ID1);
        //两条线都有进卧转立任务，直接结束
        if (Const.BIG_STORAGE_REQUEST_IN.equals(d01Request)
                && Const.BIG_STORAGE_REQUEST_IN.equals(d04Request)
                && StringUtils.isNotBlank(d01ID1)
                && StringUtils.isNotBlank(d04ID1)) {
            log.info("两条线都存在进片任务，结束任务");
            return;
        }
        //获取两条线卧转立是否有玻璃，且任务状态都为2
        List<String> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
        if (CollectionUtils.isEmpty(lineList)) {
            log.info("两条线卧转立为空或者有进片任务未完成，结束任务");
            return;
        }
//        0：不干预 ； 1：条件满足情况下立即发车
        String d02GoAdress = plcParameterObject.getPlcParameter("D02Go").getAddress();
        //        0：不干预 ； 1：条件满足情况下立即发车
        String d05GoAdress = plcParameterObject.getPlcParameter("D05Go").getAddress();
        String line1 = lineList.get(0);
        String flagLine = line1.equals(Const.A09_OUT_TARGET_POSITION) ? d01ID1 : d04ID1;
        if (lineList.size() == 1) {
            //发送
            if (StringUtils.isNotBlank(flagLine)) {
                return;
            }
            //计算任务表进片格子 发送进片任务
            computeTargetByLine(Integer.parseInt(flagLine), d02GoAdress, d05GoAdress);
        }
        if (StringUtils.isBlank(d01ID1) && StringUtils.isBlank(d04ID1)) {
            //比较最早一片任务的版图id及版序 求出卧转立的线路
            Integer line = getStartLine();
            //计算任务表进片格子 发送进片任务
            computeTargetByLine(line, d02GoAdress, d05GoAdress);
            return;
        }
        int outLine = StringUtils.isBlank(d01ID1) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
        //计算任务表进片格子 发送进片任务
        computeTargetByLine(outLine, d02GoAdress, d05GoAdress);
    }

    @Scheduled(fixedDelay = 5000)
    public void plcToHomeEdgOutTask() {
        //todo:是否有正在出片的钢化任务
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
        //任务数据  获取车子存放玻璃最大数量  玻璃间隔
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
            log.info("有正在出片的钢化任务");
            //打车剩余尺寸
            AtomicReference<Integer> remainWidth = new AtomicReference<>(Const.BIG_STORAGE_WIDTH);
            temperingGlassInfoList.stream().forEach(e -> {
                if (bigStorageCageOutTaskList.size() > 5 || e.getWidth() > remainWidth.get()) {
                    return;
                }
                remainWidth.set(remainWidth.get() - e.getWidth().intValue() - Const.BIG_STORAGE_GAP);
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getState(), Const.A09_OUT_TARGET_POSITION,
                        0, 0, 1));
            });
            bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
            return;
        }

        //todo:获取状态字  钢化优先 or 人工下片优先
        if (true) {
            //todo:钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
            TemperingLayoutDTO temperingLayoutDTO = bigStorageCageDetailsService.temperingIsAll();
            if (null != temperingLayoutDTO) {
                //玻璃到齐
                //todo: 到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务  结束
                List<BigStorageCageDetails> bigStorageCageDetails = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                        .eq(BigStorageCageDetails::getTemperingLayoutId, temperingLayoutDTO.getTemperingLayoutId())
                        .eq(BigStorageCageDetails::getEngineerId, temperingLayoutDTO.getEngineerId()));
                List<TemperingGlassInfo> temperingGlassInfos = bigStorageCageDetails.stream().map(e -> {
                    TemperingGlassInfo info = new TemperingGlassInfo();
                    BeanUtils.copyProperties(e, info);
                    return info;
                }).collect(Collectors.toList());
                temperingGlassInfoService.saveBatch(temperingGlassInfos);

                //打车剩余尺寸
                AtomicReference<Integer> remainWidth = new AtomicReference<>(Const.BIG_STORAGE_WIDTH);
                temperingGlassInfoList.stream().forEach(e -> {
                    if (bigStorageCageOutTaskList.size() > 5 || e.getWidth() > remainWidth.get()) {
                        return;
                    }
                    remainWidth.set(remainWidth.get() - e.getWidth().intValue() - Const.BIG_STORAGE_GAP);
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getState(), Const.A09_OUT_TARGET_POSITION,
                            0, 0, 1));
                });
                bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
                return;
            }
            //todo: 未到齐 执行内部调度任务 结束

        }
        //todo:笼内是否有人工下片玻璃 有直接出  无 结束


    }


    /**
     * 按照玻璃id判断玻璃状态及卧转立是否可直接启动
     */
    public Boolean judgeGlassTypeStatus(String glassId, Integer line) {
        //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、获取卧转立剩余宽度
        Map<String, Object> map = bigStorageCageFeedTaskService.getMap(new QueryWrapper<BigStorageCageFeedTask>()
                .select("cast(5000 - sum(width + 20)  as INT)as remainWidth")
                .eq("line", line).eq("task_state", Const.BIG_STORAGE_IN_UP));
        Integer remainWidth = null == map ? 5000 : Integer.parseInt(map.get("remainWidth") + "");
        //2、获取卧转立
        Integer widthFirst = edgGlassTaskInfoList.get(0).getWidth();
        if (edgGlassTaskInfoList.size() == 1) {
            if (remainWidth >= widthFirst) {
                addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst);
                return Boolean.FALSE;
            } else {
                //记录无法放下玻璃，后续判断启动
                return Boolean.TRUE;
            }
        }
        Integer widthSecond = edgGlassTaskInfoList.get(1).getWidth();
        if (remainWidth >= widthFirst) {
            if (remainWidth - widthFirst - Const.BIG_STORAGE_GAP >= widthSecond) {
                addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthSecond);
            } else {
                addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthSecond);
            }
            return Boolean.FALSE;

        } else {
            return Boolean.TRUE;
        }
    }

    /**
     * 添加任务信息
     */
    private Boolean addFeedTask(String glassId, Integer line, Integer taskType, Integer width) {
        BigStorageCageFeedTask bigStorageCageFeedTask = new BigStorageCageFeedTask();
        bigStorageCageFeedTask.setGlassId(glassId);
        bigStorageCageFeedTask.setTaskState(Const.BIG_STORAGE_REQUEST_IN);
        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, String d02GoAdress, String d05GoAdress) {
        //1、获取任务表中的所有玻璃（指定线路且已经进卧转立完成）
        List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .eq(BigStorageCageFeedTask::getLine, line)
                .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                .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));
        AtomicReference<Integer> temperingLayoutIdTemp = new AtomicReference<>(0);
        AtomicReference<Integer> temperingFeedSequenceTemp = new AtomicReference<>(0);
        AtomicReference<BigStorageDTO> bigStorageDTO = new AtomicReference<>(new BigStorageDTO());
        Map<String, GlassInfo> glassInfoMap = glassInfos.stream().collect(Collectors.toMap(GlassInfo::getGlassId, p -> p));
        List<BigStorageCageDetails> bigStorageCageDetailsList = new ArrayList<>();
        AtomicBoolean taskFlag = new AtomicBoolean(Boolean.TRUE);
        taskList.stream().forEach(e -> {
            BigStorageCageDetails cageDetails = new BigStorageCageDetails();
            //按照版图信息获取进片笼子格子号
            GlassInfo info = glassInfoMap.get(e.getGlassId());
            BeanUtils.copyProperties(info, cageDetails);
            if (temperingLayoutIdTemp.equals(info.getTemperingLayoutId())
                    && temperingFeedSequenceTemp.equals(info.getTemperingFeedSequence() + 1)
                    && info.getWidth() <= bigStorageDTO.get().getWidth()) {
                bigStorageDTO.get().setWidth(bigStorageDTO.get().getWidth() - info.getWidth().intValue() - Const.BIG_STORAGE_GAP);
            } else {
                bigStorageDTO.set(bigStorageCageDetailsService.queryTargetSlotByTempering(info));
            }
            e.setTargetSlot(bigStorageDTO.get().getSlot());
            cageDetails.setSlot(bigStorageDTO.get().getSlot());
            cageDetails.setState(Const.GLASS_STATE_IN);
            temperingLayoutIdTemp.set(info.getTemperingLayoutId());
            temperingFeedSequenceTemp.set(info.getTemperingFeedSequence());
            bigStorageCageDetailsList.add(cageDetails);
            taskFlag.set(bigStorageCageFeedTaskService.updateById(e));
            if (!taskFlag.get()) {
                return;
            }
        });
        //3、更新进片任务表  遇到问题：无法批量更新，批量更新无法走指定从库

        //4、在详情表中加入进片玻璃信息
        bigStorageCageDetailsService.saveBatch(bigStorageCageDetailsList);
        if (taskFlag.get()) {
            String lineAddress = line.equals(Const.A09_OUT_TARGET_POSITION) ? d02GoAdress : d05GoAdress;
//            S7object.getinstance().plccontrol.writeWord(lineAddress, (short) 1);
        }
        return taskFlag.get();
    }
}