package com.zy.asrs.task;

import com.alibaba.excel.util.StringUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.mes.MesReturn;
import com.zy.asrs.mapper.CanFinMapper;
import com.zy.asrs.service.OrderPakoutService;
import com.zy.asrs.service.TaskService;
import com.zy.asrs.service.WrkDetlService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.service.impl.BasDevpServiceImpl;
import com.zy.asrs.service.impl.RcsServiceImpl;
import com.zy.asrs.task.core.ReturnT;
import com.zy.asrs.task.handler.AGVTaskReportHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;

@Component
public class AGVTaskReportScheduler {

    private static final Logger log = LoggerFactory.getLogger(WorkMastScheduler.class);
    @Autowired
    private TaskService taskService;
    @Autowired
    private AGVTaskReportHandler AGVTaskReportHandler;
    @Value("${hik.switch}")
    private Boolean switchErpReportOld;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private BasDevpServiceImpl basDevpService;
    @Autowired
    private OrderPakoutService orderPakoutService;
    @Autowired
    private CanFinMapper canFinMapper;
    @Value("${mes.url}")
    private String MES_URL;

    /**
     * 满板和空板出库任务，出到输送线后创建AGV搬运任务
     */
    @Scheduled(cron = "0/3 * * * * ? ")
    private void createAGVTask() {
        if (!switchErpReportOld) {
            return;
        }
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", 30));
        if (wrkMasts.isEmpty()) {
            return;
        }
        for (WrkMast wrkMast : wrkMasts) {
            //查询是否有源站和目标站有一样的agv搬运任务
            //如果有则跳过本次agv搬运任务下发

            //mes给的agv目标站点需要解析 Q：区域 ； Z： 站点
            String[] split = wrkMast.getMemo().split("-");
            //入出库状态： 3.站到站  4.站到区域
            Integer ioType = split[0].equals("Q") ? 4 : 3;
            //agv目标站点
            String stnNo = split[1];
            Task task1 = taskService.selectOne(new EntityWrapper<Task>()
                    .in("source_sta_no", wrkMast.getSourceStaNo(), wrkMast.getMemo())
                    .in("sta_no", wrkMast.getSourceStaNo(), wrkMast.getMemo()));
            if (Cools.isEmpty(task1)) {

                //生成AGV搬运出库任务
                // 保存工作档
                Task task = new Task();
                Date date = new Date();
                String TaskNo = wrkMast.getUserNo();
                String taskType = "AGV";
                List<WrkDetl> wrkDetls = wrkDetlService.selectByWrkNo(wrkMast.getWrkNo());

                if (wrkMast.getIoType()==110){
                    taskType = "ZX-AGV-08-1";
                }else{
                    if (wrkDetls != null && !Cools.isEmpty(wrkDetls.get(0).getOrderNo())){
                        TaskNo = wrkDetls.get(0).getOrderNo();
//                        OrderPakout orderPakout = orderPakoutService.selectByNo(wrkDetls.get(0).getOrderNo());
//                        if (orderPakout.getDocType()==11){
//                            taskType = "PP-AGV";
//                        }else if (orderPakout.getDocType()==12){
//                            taskType = "ZP-AGV";
//                        }
                        taskType = "ZP-AGV";
                    }
                }

                task.setWrkNo(wrkMast.getWrkNo())
                        .setTaskNo(TaskNo)
                        .setIoTime(date)
                        .setWrkSts(301L) // 工作状态：301.任务下发
                        .setIoType(ioType) // 入出库状态： 3.站到站  4.站到区域
                        .setTaskType(taskType)
                        .setIoPri(10D)
                        .setFullPlt("Y") // 满板：Y
                        .setPicking("N") // 拣料
                        .setExitMk("N")// 退出
                        .setStaNo(wrkMast.getMemo())
                        .setSourceStaNo(wrkMast.getSourceStaNo())
                        .setEmptyMk("N")// 空板
                        .setBarcode(wrkMast.getBarcode())// 托盘码
                        .setLinkMis("N")
                        .setAppeUser(9945L)
                        .setAppeTime(date)
                        .setModiUser(9945L)
                        .setModiTime(date);
                if (!taskService.insert(task)) {
                    throw new CoolException("保存工作档失败");
                } else {
                    if (!wrkMast.getBarcode().isEmpty() && !wrkMast.getMemo().isEmpty()) {
                        JSONObject map = new JSONObject();
                        map.put("taskNo", TaskNo);
                        map.put("barCode", wrkMast.getBarcode());
                        map.put("staNo", wrkMast.getStaNo());
                        log.info("本次出库托盘：{}, 目标站{}", wrkMast.getBarcode(), wrkMast.getMemo());
                        String url = "ReceiveFinishedPalletCode";
                        String URL = MES_URL + url;
                        String response = RcsServiceImpl.sendPost(URL, JSONObject.toJSONString(map));
                        if (!StringUtils.isEmpty(response) && response.contains("Success")){
                            MesReturn mesReturn = JSONObject.parseObject(response, MesReturn.class);
                            if("1".equals(mesReturn.getSuccess())) {
                                log.info("上报完成 ==> 本次出库托盘：{}, 目标站{}", wrkMast.getBarcode(), wrkMast.getMemo());
                            }else {
                                log.error("上报失败 ==> 本次出库托盘：{}, 目标站{}", wrkMast.getBarcode(), wrkMast.getMemo());
                            }
                        }
                    }
                    wrkMast.setWrkSts(31L);//31.AGV搬运任务创建成功
                    wrkMast.setModiTime(date);
                    wrkMastService.updateById(wrkMast);
                }
            }
        }
    }

    /**
     * AGV 任务下发接口，定时给AGV下发任务
     */
    @Scheduled(cron = "0/5 * * * * ? ")
    private void execute() {
        if (!switchErpReportOld) {
            return;
        }
        //查询所有agv待下发任务
        List<Task> wrkSts = taskService.selectList(new EntityWrapper<Task>().eq("wrk_sts", 301).orderBy("appe_time"));
        if (wrkSts != null && !wrkSts.isEmpty()) {
            for (Task task : wrkSts) {

                if (!task.getTaskType().equals("AGV空料架回缓存区") && !task.getTaskType().equals("AGV补空料架")){
                    if((task.getStaNo().equals("402") || task.getStaNo().equals("401")) && task.getTaskType().equals("")){
                        //筛选全部还未完成的出库任务
                        List<OrderPakout> orderPakouts = orderPakoutService.selectList(new EntityWrapper<OrderPakout>()
                                .in("settle", 1, 2)     // 1表示还未开始，2表示正在执行
                                .eq("doc_type", 12)
                                .orderBy("order_time", true));
                        if (!orderPakouts.isEmpty()) {
                            //获取第一条入库单
                            OrderPakout orderPakout = orderPakouts.get(0);
                            // 如果第一条还未开始的出库任务时间早于第一条未完成的入库任务时间，跳过，不执行
                            if (orderPakout.getCreateTime().getTime() < task.getWrkDate().getTime()){
                                continue;
                            }
                        }
                    }
                }

//                List<CanFin> canFinList = canFinMapper.selectList(new EntityWrapper<CanFin>()
//                        .orderBy("apply_time", true)
//                );
//                if (!canFinList.isEmpty()) {
//                    CanFin firstCanFin = canFinList.get(0);
//                    // 检查 InNo 是否为空
//                    if (firstCanFin.getInNo() != null) {
//                        // 检查当前任务是否与转序任务相关
//                        if (task.getStaNo().equals("401") || task.getStaNo().equals("402")){
//                            List<WrkMast> wrkMasts1 = wrkMastService.selectList(new EntityWrapper<WrkMast>()
//                                    .in("io_type", 1, 10));
//                            BasDevp basDevp = basDevpService.checkSiteStatus(Integer.parseInt(task.getStaNo()));
//                            if (basDevp.getWrkNo() != 0 || !wrkMasts1.isEmpty()){
//                                continue;
//                            }
//
//                        }
//                    }
//                }

                //查询是否有正在作业的源站和目标站有一样的agv搬运任务
                //如果有则跳过本次agv搬运任务下发
                Task task1 = taskService.selectOne(new EntityWrapper<Task>()
                        .eq("wrk_sts", 302)
                        .andNew()
                        .in("source_sta_no", task.getSourceStaNo(), task.getStaNo())
                        .or()
                        .in("sta_no", task.getStaNo(), task.getSourceStaNo()));
                Boolean flag = true;
                if (Cools.isEmpty(task1)) {
                    //agv搬运移动任务下发时，搬运目标点是否是立库AGV和堆垛机接驳站点
                    //如果是接驳站点则需要判断接驳站点是否有空料架
                    //如果有空料架需要判断是否有出库任务
                    //有出库任务则禁止下发本次搬运任务

                    if (task.getStaNo().equals("401") || task.getStaNo().equals("402") || task.getStaNo().equals("307")) {
                        flag = false;
                        BasDevp basDevp = basDevpService.checkSiteStatus(Integer.parseInt(task.getStaNo()));
                        if (basDevp != null && !Cools.isEmpty(basDevp.getInreq1())
                                && basDevp.getInreq1().equals("Y")
                                && basDevp.getLoading().equals("N")
                                && basDevp.getWrkNo()!=9991
                                && basDevp.getWrkNo()!=9999) {
                            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                                    .in("io_type", 101, 110)
                                    .le("wrk_sts", 14)
                                    .eq("sta_no", task.getStaNo()));
                            List<WrkMast> wrkMasts1 = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("io_type", 1).eq("sta_no", task.getStaNo()));
                            if (Cools.isEmpty(wrkMasts)&&Cools.isEmpty(wrkMasts1)) {
                                //判断是否已经生成空料架搬运回空料架补库区
                                //如果有的话，不在生成任务
                                Task task2 = taskService.selectOne(new EntityWrapper<Task>().eq("task_type","AGV空料架回缓存区").eq("source_sta_no", task.getStaNo()));
                                //有入库任务搬运，需要生成空料架搬运到空料架缓冲区AGV任务
                                if (Cools.isEmpty(task2)) {

                                    //生成AGV搬运出库任务
                                    // 保存工作档
                                    String SourceStaNo = "";
                                    if (task.getStaNo().equals("401")) {
                                        //大料架缓冲区
                                        SourceStaNo = "Q-E3";
                                    }else if (task.getStaNo().equals("402")) {
                                        SourceStaNo = "Q-E2";
                                    }else if (task.getStaNo().equals("307")) {
                                        SourceStaNo = "Q-E1";
                                    }
                                    Task task3 = new Task();
                                    Date date = new Date();
                                    String TaskNo = task.getTaskNo() + "bb" + date.getTime();
                                    task3.setWrkNo(999999)
                                            .setTaskNo(TaskNo)
                                            .setIoTime(date)
                                            .setWrkSts(301L) // 工作状态：301.任务下发
                                            .setIoType(4) // 入出库状态： 3.站到站  4.站到区域
                                            .setTaskType("AGV空料架回缓存区")
                                            .setIoPri(10D)
                                            .setFullPlt("Y") // 满板：Y
                                            .setPicking("N") // 拣料
                                            .setExitMk("N")// 退出
                                            .setStaNo(SourceStaNo)
                                            .setSourceStaNo(task.getStaNo())//空料架缓存区E1
                                            .setEmptyMk("N")// 空板
                                            .setBarcode("")// 托盘码
                                            .setLinkMis("N")
                                            .setAppeUser(9945L)
                                            .setAppeTime(date)
                                            .setModiUser(9945L)
                                            .setModiTime(date);
                                    if (!taskService.insert(task3)) {
                                        throw new CoolException("保存工作档失败");
                                    }
                                    break;
                                }
                            }
                        }else if(basDevp != null && !Cools.isEmpty(basDevp.getInreq1())
                                && basDevp.getInreq1().equals("N")
                                && basDevp.getLoading().equals("N")
                                ) {
                            flag = true;
                        }

                    }
                    if (flag || task.getTaskType().equals("AGV空料架回缓存区")) {
                        //AGV任务下发
                        ReturnT<String> start = AGVTaskReportHandler.start(task);
                        if (!start.isSuccess()) {
                            task.setUpdMk("X");
                            task.setErrorMemo(start.getMsg());
                            task.setCtnType(task.getCtnType()+1);//下发任务计数
                            task.setModiTime(new Date());
                            if (!taskService.updateById(task)) {
                                log.error("工作档[workNo={}]标记待处理失败", task.getWrkNo());
                            }
                            break;
                        }else {
                            task.setCtnType(task.getCtnType()+1);
                            task.setModiTime(new Date());
                            task.setWrkSts(302L);//任务执行中
                            if (!taskService.updateById(task)) {
                                log.error("工作档[workNo={}]标记待处理失败", task.getWrkNo());
                            }
                        }
                    }


                }
            }
        }
    }
}