package com.zy.asrs.wms.apis.wcs.schedule;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.zy.asrs.wms.asrs.entity.Task;
import com.zy.asrs.wms.asrs.entity.enums.TaskStsType;
import com.zy.asrs.wms.asrs.service.TaskService;
import com.zy.asrs.wms.asrs.service.WorkService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;

import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;

@Slf4j
@Component
public class ScheduleJobs {

    @Autowired
    private DataSourceTransactionManager transactionManager;
    @Autowired
    private TaskService taskService;
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private WorkService workService;


    /***
     * 入库任务---通知ESS输送线流动
     */
    @Scheduled(cron = "0/3 * * * * ? ")
    @Transactional(rollbackFor = Exception.class)
    public void conveyorStart() {
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
                .eq(Task::getTaskSts, TaskStsType.WCS_CONTAINER_RECEIVE.id).eq(Task::getStatus, 1));
        tasks.forEach(task -> {
            try {
//                ConveyorStarParam conveyorStarParam = new ConveyorStarParam();
//                conveyorStarParam.setSlotCode(task.getOriginLoc())
//                        .setContainerCode(task.getBarcode());
//                //调用三方接口，将任务推送至ESS平台
//                MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
//                // 设置请求参数
//                params.add("params", JSONObject.toJSONString(conveyorStarParam));
//                log.info("请求地址：{}，请求参数：{}", Constant.CONVEYOR_START, JSONObject.toJSONString(conveyorStarParam));
//                HttpHeaders headers = new HttpHeaders();
//                headers.add("Content-Type", "application/json");
//                HttpEntity httpEntity = new HttpEntity<>(params, headers);
//                // 请求
//                ResponseEntity<String> exchange = restTemplate.exchange(Constant.CONVEYOR_START, HttpMethod.POST, httpEntity, String.class);
//                log.info("下发流动通知 返回结果：{}", exchange);
//                if (exchange.getBody() == null) {
//                    throw new CoolException("下发流动通知失败！！");
//                } else {
//                    CommonReponse commonReponse = JSON.toJavaObject(JSON.parseObject(exchange.getBody()), CommonReponse.class);
//                    if (commonReponse.getCode() == 0) {
                        taskService.update(new LambdaUpdateWrapper<Task>()
                                .eq(Task::getId, task.getId())
                                .set(Task::getTaskSts, TaskStsType.WCS_CONVEYOR_START.id));
//                        log.info(task.getTaskNo() + "下发流动通知" + commonReponse.getMsg());
//                    } else {
//                        throw new CoolException("下发流动通知失败！！");
//                    }
//                }
            } catch (Exception ex) {
                log.error(ex.getMessage());
            } finally {
                //如果异常修改禁用状态
//                taskService.update(new LambdaUpdateWrapper<Task>().set(Task::getStatus, 0).eq(Task::getId, task.getId()));
            }
        });

    }


    /***
     * 入库任务---下发入库任务
     * 每隔3秒，刷新当前通知档列表，下发待入库订单至ESS
     * 查询当前任务列表，
     */
    @Scheduled(cron = "0/3 * * * * ? ")
    @Transactional(rollbackFor = Exception.class)
    public void waitPakinSchedule() {
        //获取当前任务档中，所有为待入库状态的任务档，按时间升序排列
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
//                        .eq(Task::getTaskType, 1)
                        .eq(Task::getTaskSts, TaskStsType.GENERATE_IN.id))
                .stream().sorted(Comparator.comparing(Task::getTaskSts))
                .collect(Collectors.toList());

        // 数据组装
//        PublishTasksParam tasksParam = new PublishTasksParam();
//        //TODO 确认是否需要单任务多容器码的需求，目前系统都是单容器码生成单任务，多任务明细（物料混装）
//        tasks.forEach(task -> {
//            List<TaskParam> params = new ArrayList<>();
//            TaskParam param = new TaskParam();
//            //设置容器编码
//            param.setTaskCode(task.getTaskNo());
//            List<TaskDescribe> taskDescribes = new ArrayList<>();
//            TaskDescribe describe = new TaskDescribe();
//            //设置目标库位，站点
//            describe.setContainerCode(task.getBarcode())
//                    .setToLocationCode(task.getTargetLoc())
//                    .setToStationCode(task.getTargetSite());
//            taskDescribes.add(describe);
//            param.setTaskDescribe(taskDescribes);
//            params.add(param);
//            tasksParam.setTasks(params);
//        });
//
//        tasksParam.setTaskType("putaway");
//        // TODO 多任务多订单，统一调度，是否会出现部分成功，部分失败的情况
//        //调用三方接口，将任务推送至ESS平台
//        MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
//        // 设置请求参数
//        params.add("params", JSONObject.toJSONString(tasksParam));
//        log.info("请求地址：{}，请求参数：{}", Constant.ISSUE_TASK_OF_EVENT, JSONObject.toJSONString(tasksParam));
//        HttpHeaders headers = new HttpHeaders();
//        headers.add("Content-Type", "application/json");
//        HttpEntity httpEntity = new HttpEntity<>(params, headers);
//        // 请求
//        ResponseEntity<String> exchange = restTemplate.exchange(Constant.ISSUE_TASK_OF_EVENT, HttpMethod.POST, httpEntity, String.class);
//        log.info("下发任务 返回结果：{}", exchange);
//        if (exchange.getBody() == null) {
//            throw new CoolException("下发任务失败！！");
//        } else {
//            CommonReponse reponse = (CommonReponse) JSON.parse(exchange.getBody());
//            if (reponse.getCode() == 0) {
                //请求成功后，统一修改所有任务档状态为入库执行中。
                tasks.forEach(task -> {
                    taskService.update(new LambdaUpdateWrapper<Task>()
                            .set(Task::getTaskSts, TaskStsType.WCS_EXECUTE_IN.id)
                            .eq(Task::getBarcode, task.getBarcode()));
                });
//            } else {
//                // TODO 请求失败需确认是否存在部分成功的情况，部分成功需要单独刷新成功的任务档状态
//                throw new CoolException(reponse.getMsg());
//            }
//        }
    }


    /**
     * //fixme 弃用
     * 出库任务---通知容器流动
     * 每隔3秒，获取当前出库任务列表状态为COMPLETE_OUT的任务，并通知ESS流动输送线
     */
//    @Scheduled(cron = "0/5 * * * * ? ")
    @Transactional(rollbackFor = Exception.class)
    public void conveyorToNotify() {
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
                .eq(Task::getTaskSts, TaskStsType.WCS_EXECUTE_OUT_CONVEYOR.id).eq(Task::getStatus, 1));

        // 还需要再修改
        tasks.forEach(task -> {
//            try {
//                ConveyorStarParam conveyorStarParam = new ConveyorStarParam();
//                conveyorStarParam.setSlotCode(task.getOriginLoc())
//                        .setContainerCode(task.getBarcode());
//                if (task.getTaskType() == 101) { //任务类型为101全盘出库，直接取下容器，传200
//                    conveyorStarParam.setDirection("200");
//                } else if (task.getTaskType() == 103) { //如果为任务类型为103，需走回库操作，传100
//                    conveyorStarParam.setDirection("100");
//                }
//                //调用三方接口，将任务推送至ESS平台
//                MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
//                // 设置请求参数
//                params.add("params", JSONObject.toJSONString(conveyorStarParam));
//                log.info("请求地址：{}，请求参数：{}", Constant.CONVEYOR_START, JSONObject.toJSONString(conveyorStarParam));
//                HttpHeaders headers = new HttpHeaders();
//                headers.add("Content-Type", "application/json");
//                HttpEntity httpEntity = new HttpEntity<>(params, headers);
//                // 请求
//                ResponseEntity<String> exchange = restTemplate.exchange(Constant.CONVEYOR_START, HttpMethod.POST, httpEntity, String.class);
//                log.info("下发流动通知 返回结果：{}", exchange);
//                if (exchange.getBody() == null) {
//                    throw new CoolException("下发流动通知失败！！");
//                } else {
//                    CommonReponse commonReponse = JSON.toJavaObject(JSON.parseObject(exchange.getBody()), CommonReponse.class);
//                    if (commonReponse.getCode() == 0) {
                        //流动通知下发完成后，修改任务状态为输送线流动中。。
//                        taskService.update(new LambdaUpdateWrapper<Task>()
//                                .eq(Task::getId, task.getId())
//                                .set(Task::getTaskSts, TaskStsType.COMPLETE_OUT.id));

//                        log.info(task.getTaskNo() + "下发流动通知" + commonReponse.getMsg());
//                    } else {
//                        throw new CoolException("下发流动通知失败！！");
//                    }
//                }
//            } catch (Exception ex) {
//                log.error(ex.getMessage());
//            } finally {
//                //如果异常修改禁用状态
//                taskService.update(new LambdaUpdateWrapper<Task>().set(Task::getStatus, 0)
//                        .set(Task::getUpdateTime, new Date())
//                        .eq(Task::getId, task.getId()));
//            }
        });
    }


    /**
     * 出库任务--- 每隔3秒，获取当前出库任务列表状态为GENERATE_OUT的任务，下发任务至ESS
     * //TODO  出库任务分两种：
     * //TODO 1. 正常出库后，清除任务，
     * //TODO 2. 出库后还有库存，需要添加容器回库操作
     */
    @Scheduled(cron = "0/3 * * * * ? ")
    @Transactional(rollbackFor = Exception.class)
    public void waveToTask() {
        //获取当前任务档中，所有为待出库状态的任务档，按时间升序排列
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
                        .ge(Task::getTaskType, 101) //TODO 如何确认是101，还是103
                        .eq(Task::getTaskSts, TaskStsType.GENERATE_OUT.id));
        if (tasks.isEmpty()) {
            return;
        }
        tasks.stream().sorted(Comparator.comparing(Task::getTaskSts))
                .collect(Collectors.toList());

        // 数据组装
//        PublishTasksParam tasksParam = new PublishTasksParam();
//        //TODO 确认是否需要单任务多容器码的需求，目前系统都是单容器码生成单任务，多任务明细（物料混装）
//        tasks.forEach(task -> {
//            List<TaskParam> params = new ArrayList<>();
//            TaskParam param = new TaskParam();
//            //设置容器编码
//            param.setTaskCode(task.getTaskNo());
//            List<TaskDescribe> taskDescribes = new ArrayList<>();
//            TaskDescribe describe = new TaskDescribe();
//            //设置目标库位，站点
//            describe.setContainerCode(task.getBarcode())
//                    .setToLocationCode(task.getTargetLoc())
//                    .setToStationCode(task.getTargetSite());
//            taskDescribes.add(describe);
//            param.setTaskDescribe(taskDescribes);
//            params.add(param);
//            tasksParam.setTasks(params);
//        });
//
//        tasksParam.setTaskType("carry");
//        // TODO 多任务多订单，统一调度，是否会出现部分成功，部分失败的情况
//        //调用三方接口，将任务推送至ESS平台
//        MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
//        // 设置请求参数
//        params.add("params", JSONObject.toJSONString(tasksParam));
//        log.info("请求地址：{}，请求参数：{}", Constant.ISSUE_TASK_OF_EVENT, JSONObject.toJSONString(tasksParam));
//        HttpHeaders headers = new HttpHeaders();
//        headers.add("Content-Type", "application/json");
//        HttpEntity httpEntity = new HttpEntity<>(params, headers);
//        // 请求
//        ResponseEntity<String> exchange = restTemplate.exchange(Constant.ISSUE_TASK_OF_EVENT, HttpMethod.POST, httpEntity, String.class);
//        log.info("下发任务 返回结果：{}", exchange);
//        if (exchange.getBody() == null) {
//            throw new CoolException("下发任务失败！！");
//        } else {
//            CommonReponse reponse = (CommonReponse) JSON.parse(exchange.getBody());
//            if (reponse.getCode() == 0) {
                //请求成功后，统一修改所有任务档状态为入库执行中。
                tasks.forEach(task -> {
                    taskService.update(new LambdaUpdateWrapper<Task>()
                            .set(Task::getTaskSts, TaskStsType.WCS_EXECUTE_OUT.id)
                            .eq(Task::getId, task.getId()));
                });
//            } else {
//                // TODO 请求失败需确认是否存在部分成功的情况，部分成功需要单独刷新成功的任务档状态
//                throw new CoolException(reponse.getMsg());
//            }
//        }
    }
}