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

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.cfg.CoercionAction;
import com.fasterxml.jackson.databind.cfg.CoercionInputShape;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wms.apis.wcs.entity.domain.SystemProperties;
import com.zy.asrs.wms.apis.wcs.entity.request.ConveyorStarParam;
import com.zy.asrs.wms.apis.wcs.entity.request.PublishTasksParam;
import com.zy.asrs.wms.apis.wcs.entity.request.TaskDescribe;
import com.zy.asrs.wms.apis.wcs.entity.request.TaskParam;
import com.zy.asrs.wms.apis.wcs.entity.response.CommonReponse;
import com.zy.asrs.wms.asrs.entity.*;
import com.zy.asrs.wms.asrs.entity.dto.OrderOutMergeDto;
import com.zy.asrs.wms.asrs.entity.enums.LocStsType;
import com.zy.asrs.wms.asrs.entity.enums.TaskStsType;
import com.zy.asrs.wms.asrs.service.*;
import com.zy.asrs.wms.asrs.service.impl.LocServiceImpl;
import com.zy.asrs.wms.utils.Utils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
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.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.util.*;
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;
    @Resource
    private SystemProperties properties;
    @Autowired
    private LocServiceImpl locService;
    @Autowired
    private LocDetlService locDetlService;
    @Autowired
    private TaskDetlService taskDetlService;
    @Autowired
    private LocDetlFieldService locDetlFieldService;
    @Autowired
    private TaskDetlFieldService taskDetlFieldService;
    @Autowired
    private CacheSiteService cacheSiteService;
    @Autowired
    private OperationPortService operationPortService;

    /***
     * 入库任务---通知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.getOriginSite())
                        .setContainerCode(task.getBarcode())
                        .setDirection("100");
                // 原始报文
                log.info("通知ESS输送线流动请求地址：{}，请求参数：{}", "http://192.168.2.200:9046/conveyor/moveContainer", JSONObject.toJSONString(conveyorStarParam));
                HttpHeaders headers = new HttpHeaders();
                headers.add("Content-Type", "application/json");
                headers.add("api-version", "v2.0");
                HttpEntity httpEntity = new HttpEntity<>(conveyorStarParam, headers);
                // 调用三方接口，将任务推送至ESS平台
                ResponseEntity<String> exchange = restTemplate.exchange("http://192.168.2.200:9046/conveyor/moveContainer", HttpMethod.POST, httpEntity, String.class);
                log.info("下发流动通知 返回结果：{}", exchange);
                if (exchange.getBody() == null) {
                    throw new CoolException("下发流动通知失败！！");
                } else {
                    ObjectMapper objectMapper = new ObjectMapper();
                    objectMapper.coercionConfigDefaults()
                            .setCoercion(CoercionInputShape.EmptyString, CoercionAction.AsEmpty);
                    CommonReponse commonReponse = objectMapper.readValue(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));
                    } else {
                        throw new CoolException("下发流动通知失败！！");
                    }
                }
            } catch (Exception ex) {
                log.error(ex.getMessage());
            }
        });

    }

    /**
     * 生成自动盘点任务
     */
//    @Scheduled(cron = "0/50 * * * * ?")
//    @Transactional(rollbackFor = Exception.class)
    public void genCheckTask() {
        Loc locs = locService.getOne(new LambdaQueryWrapper<Loc>().eq(Loc::getLocStsId, LocStsType.F.val()).orderByAsc(Loc::getLocNo).last("limit 1"));
        if (Objects.isNull(locs)) {
            return;
        }
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().select(Task::getId).eq(Task::getTaskType, 107L));
        if (!tasks.isEmpty() && tasks.size() >= 4) {
            //默认生成四个盘点任务，超过4个，停止生成盘点任务;
            return;
        }
        OperationPort operationPort = operationPortService.getOne(new LambdaQueryWrapper<OperationPort>().last("ORDER BY RAND() LIMIT 1;"));
        if (operationPort == null || Objects.isNull(operationPort)) {
            throw new CoolException("作业口不存在");
        }
        Task task = new Task();
        task.setTaskNo(workService.generateTaskNo(TaskStsType.GENERATE_OUT.id));
        task.setTaskSts(TaskStsType.GENERATE_OUT.id);
        task.setTaskType(107L); //默认107盘点任务，盘点任务没有，按103处理
        task.setIoPri(workService.generateIoPri(TaskStsType.GENERATE_OUT.id));
        task.setOriginLoc(locs.getLocNo());
        task.setTargetSite(operationPort.getFlag());
        task.setBarcode(locs.getBarcode());

        if (!taskService.save(task)) {
            throw new CoolException("任务生成失败！！");
        }

        List<LocDetl> locDetls = locDetlService.list(new LambdaQueryWrapper<LocDetl>().eq(LocDetl::getLocId, locs.getId()));
        if (locDetls.isEmpty()) {
            throw new CoolException("明细不存在！！");
        }

        for (LocDetl locDetl : locDetls) {
            TaskDetl taskDetl = new TaskDetl();
            taskDetl.sync(locDetl);
            taskDetl.setId(null);
            taskDetl.setTaskId(task.getId());
            taskDetl.setTaskNo(task.getTaskNo());
            taskDetl.setAnfme(locDetl.getAnfme());
            taskDetl.setStock(locDetl.getAnfme());
            taskDetl.setWaveId(null);
            taskDetl.setWaveNo(null);
            taskDetl.setOrderId(null);
            taskDetl.setOrderNo(null);
            if (!taskDetlService.save(taskDetl)) {
                throw new CoolException("保存工作档明细失败");
            }

            List<LocDetlField> locDetlFields = locDetlFieldService.list(new LambdaQueryWrapper<LocDetlField>().eq(LocDetlField::getDetlId, locDetl.getId()));
            for (LocDetlField locDetlField : locDetlFields) {
                TaskDetlField taskDetlField = new TaskDetlField();
                taskDetlField.sync(locDetlField);
                taskDetlField.setId(null);
                taskDetlField.setDetlId(taskDetl.getId());
                if (!taskDetlFieldService.save(taskDetlField)) {
                    throw new CoolException("明细扩展生成失败");
                }
            }
        }

        if (!locService.update(new LambdaUpdateWrapper<Loc>().eq(Loc::getId, locs.getId())
                .set(Loc::getUpdateTime, new Date())
                .set(Loc::getLocStsId, LocStsType.R.val()))) {
            throw new CoolException("库位状态修改失败！！");
        }
    }

    /***
     * 入库任务---下发入库任务
     * 每隔3秒，刷新当前通知档列表，下发待入库订单至ESS
     * 查询当前任务列表，
     */
    @Scheduled(cron = "0/3 * * * * ? ")
    @Transactional(rollbackFor = Exception.class)
    public void waitPakinSchedule() throws JsonProcessingException {
        //获取当前任务档中，所有为待入库状态的任务档，按时间升序排列
        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());
        if (tasks.size() == 0) {
            return;
        }

        // 数据组装
        PublishTasksParam tasksParam = new PublishTasksParam();
        //TODO 确认是否需要单任务多容器码的需求，目前系统都是单容器码生成单任务，多任务明细（物料混装）
        tasks.forEach(task -> {
            List<TaskParam> params = new ArrayList<>();
            TaskParam param = new TaskParam();
            param.setTaskCode(task.getTaskNo());

            // 处理库位映射
            String[] parts = task.getTargetLoc().split("-");
            String formatLocNo = String.format("A-%03d-%03d-%02d",
                    Integer.parseInt(parts[0]),
                    Integer.parseInt(parts[1]),
                    Integer.parseInt(parts[2]));
            TaskDescribe describe = new TaskDescribe();
            //设置目标库位，站点
            describe.setContainerCode(task.getBarcode())
                    .setToLocationCode(formatLocNo)
                    .setToStationCode(task.getTargetSite());

            param.setTaskDescribe(describe);
            params.add(param);
            tasksParam.setTasks(params);
        });

        tasksParam.setTaskType("putaway");
        // TODO 多任务多订单，统一调度，是否会出现部分成功，部分失败的情况
        log.info("下发入库任务请求地址：{}，请求参数：{}", "http://192.168.2.200:9046/task/create", JSONObject.toJSONString(tasksParam));
        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
        headers.add("api-version", "v2.0");
        HttpEntity httpEntity = new HttpEntity<>(tasksParam, headers);
        // 请求
        ResponseEntity<String> exchange = restTemplate.exchange("http://192.168.2.200:9046/task/create", HttpMethod.POST, httpEntity, String.class);
        log.info("下发任务 返回结果：{}", exchange);
        if (exchange.getBody() == null) {
            throw new CoolException("下发任务失败！！");
        } else {
            ObjectMapper objectMapper = new ObjectMapper();
            CommonReponse reponse = objectMapper.readValue(exchange.getBody(), CommonReponse.class);
            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() throws JsonProcessingException {
        //获取当前任务档中，所有为待出库状态的任务档，按时间升序排列
        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();
        List<TaskParam> params = new ArrayList<>();
        //TODO 确认是否需要单任务多容器码的需求，目前系统都是单容器码生成单任务，多任务明细（物料混装）
        tasks.forEach(task -> {
            TaskParam param = new TaskParam();
            //设置容器编码
            param.setTaskCode(task.getTaskNo());
            TaskDescribe describe = new TaskDescribe();
            //设置目标库位，站点
            describe.setContainerCode(task.getBarcode())
                    .setToLocationCode(task.getTargetLoc())
                    .setToStationCode(task.getTargetSite());
            param.setTaskDescribe(describe);
            params.add(param);
        });
        tasksParam.setTasks(params);
        tasksParam.setTaskType("carry");
        log.info("出库任务下发请求地址：{}，请求参数：{}", properties.getBaseHost() + properties.getEssReceiveTask(), JSONObject.toJSONString(tasksParam));
        HttpHeaders headers = new HttpHeaders();
        headers.add("Content-Type", "application/json");
        HttpEntity httpEntity = new HttpEntity<>(tasksParam, headers);
        // 请求
        ResponseEntity<String> exchange = restTemplate.exchange(properties.getBaseHost() + properties.getEssReceiveTask(), HttpMethod.POST, httpEntity, String.class);
        log.info("出库任务下发 返回结果：{}", exchange);
        if (exchange.getBody() == null) {
            throw new CoolException("下发任务失败！！");
        } else {
            ObjectMapper objectMapper = new ObjectMapper();
            CommonReponse reponse = objectMapper.readValue(exchange.getBody(), CommonReponse.class);
            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());
            }
        }
    }
}