package com.zy.asrs.wms.apis.wcs.services.Impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.zy.asrs.framework.common.R;
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.enums.EssTaskStatus;
import com.zy.asrs.wms.apis.wcs.entity.request.*;
import com.zy.asrs.wms.apis.wcs.entity.response.CommonReponse;
import com.zy.asrs.wms.apis.wcs.services.WcsApiService;
import com.zy.asrs.wms.asrs.entity.*;
import com.zy.asrs.wms.asrs.entity.enums.CacheSiteStatusType;
import com.zy.asrs.wms.asrs.entity.enums.OrderPickStatus;
import com.zy.asrs.wms.asrs.entity.enums.TaskStsType;
import com.zy.asrs.wms.asrs.service.*;
import io.jsonwebtoken.lang.Collections;
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.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

@Slf4j
@Service
public class WcsApiServiceImpl implements WcsApiService {

    @Autowired
    private WaitPakinService waitPakinService;
    @Autowired
    private WorkService workService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private TaskDetlService taskDetlService;
    @Autowired
    private CacheSiteService cacheSiteService;
    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private WaveSeedService waveSeedService;

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private PlatformService platformService;


    /**
     * 容器到达接收
     * 根据ESS返回的容器编码修改任务档中的输送线起始位置节点，及任务档执行状态
     * * 当前问题：
     * * //TODO 1. 目前任务下发接口沟通下来，是需要目标位置的，这里我们只是刚组拖完成，并不是通知流动，没有目标位置
     * * //TODO 2. 文档上的搬运任务下发指的都是多任务，多容器搬运，而不是我们需要物料信息同步功能
     * * //TODO 3. 流程走不通暂时先跳过，确认是否需要WMS触发料箱滚动至扫码区
     *
     * @param arrivedParam
     * @param hostId
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public R containerArrivedNotify(ContainerArrivedParam arrivedParam, String taskType, Long hostId) {
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, arrivedParam.getContainerCode()));
        if (Collections.isEmpty(tasks)) {
            return R.error("任务不存在！！");
        }

        if (taskType.equals("inStock")) {
            //DONE 根据ESS返回的容器编码修改任务档中的输送线起始位置节点，及任务档容器到达状态
            taskService.update(new LambdaUpdateWrapper<Task>()
                    .set(Task::getTaskSts, TaskStsType.WCS_CONTAINER_RECEIVE.id)
                    //输送线节点编码，不是源库位
//                    .set(Task::getOriginLoc, arrivedParam.getSlotCode())
                    .eq(Task::getBarcode, arrivedParam.getContainerCode()));
        } else {
            //容器到达时更新任务状态为：入库完成，定时任务根据状态码更新库存
            //当状态为入库完成时，更新库存信息
//            boolean update = taskService.update(new LambdaUpdateWrapper<Task>()
//                    .set(Task::getTaskSts, TaskStsType.COMPLETE_OUT.id)
//                    .set(Task::getOriginLoc, arrivedParam.getSlotCode())
//                    .eq(Task::getBarcode, arrivedParam.getContainerCode()));
            //fixme 容器到达状态更改为播种中...
            boolean update = taskService.update(new LambdaUpdateWrapper<Task>()
                    .set(Task::getTaskSts, TaskStsType.WAVE_SEED.id)
                    .set(Task::getOriginLoc, arrivedParam.getSlotCode())
                    .eq(Task::getBarcode, arrivedParam.getContainerCode()));
            if (!update) {
                throw new CoolException("容器到达任务更新失败！！");
            }

        }

        return R.success("success");
    }

    /**
     * 容器执行状态上报
     *
     * @param callbackParam
     * @param stockType
     * @param hostId
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void receiveTaskStatus(TasksStatusCallbackParam callbackParam, String stockType, Long hostId) {
        List<Task> list = taskService.list(new LambdaQueryWrapper<Task>()
                .eq(Task::getBarcode, callbackParam.getContainerCode())
                .eq(Task::getTaskNo, callbackParam.getTaskCode()));
        if (!Collections.isEmpty(list)) {
            list.forEach(task -> {
                TaskStsType taskStsType = null;
                if (stockType.equals("inStock")) { //入库任务
                    if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态
                        if (task.getTaskSts() == TaskStsType.WCS_CONVEYOR_START.id) {
                            taskStsType = TaskStsType.WCS_TOTE_LOAD;
                        } else {
                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_TOTE_LOAD.desc + "任务";
                            log.error(errMsg);
                            throw new CoolException(errMsg);
                        }
                    } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态
                        if (task.getTaskSts() == TaskStsType.WCS_TOTE_LOAD.id) {
                            taskStsType = TaskStsType.WCS_TOTE_UNLOAD;
                        } else {
                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_TOTE_UNLOAD.desc + "任务";
                            log.error(errMsg);
                            throw new CoolException(errMsg);
                        }
                    } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //TODO 需确认上报任务中，任务完成是哪个事件，目前暂定task事件
                        if (task.getTaskSts() == TaskStsType.WCS_TOTE_UNLOAD.id) {
                            taskStsType = TaskStsType.WCS_PUTAWAY_SUCESS;
                        } else {
                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_PUTAWAY_SUCESS.desc + "任务";
                            log.error(errMsg);
                            throw new CoolException(errMsg);
                        }
                    }
                    boolean result = taskService.update(new LambdaUpdateWrapper<Task>()
                            .set(Task::getRobotCode, callbackParam.getRobotCode())
                            .set(Task::getSysTaskCode, callbackParam.getSysTaskCode())
                            .set(Task::getTaskSts, taskStsType.id)
                            .set(Task::getExcudeStatus, callbackParam.getStatus())
                            .set(Task::getTaskDesc, callbackParam.getMessage())
                            .eq(Task::getBarcode, callbackParam.getContainerCode())
                            .eq(Task::getTaskNo, callbackParam.getTaskCode()));

                    //event事件为task，表明任务上报完成状态
                    if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event) && result) {
                        //任务状态修改为 99 入库完成
                        workService.completeTask(task.getId());
                    }
                } else { //出库任务
                    if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_LOAD.event)) { //上报取箱状态
                        if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT.id ) {
                            taskStsType = TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD;
                        } else {
                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.desc + "任务";
                            log.error(errMsg);
                            throw new CoolException(errMsg);
                        }
                    } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_TOTE_UNLOAD.event)) { //上报放箱状态
                        if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TOTE_LOAD.id) {
                            taskStsType = TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD;
                        } else {
                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.desc + "任务";
                            log.error(errMsg);
                            throw new CoolException(errMsg);
                        }
                    } else if (callbackParam.getEventType().equals(EssTaskStatus.TASK_EVENT_STATUS.event)) { //上报完成状态
                        if (task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TOTE_UNLOAD.id || task.getTaskSts() == TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.id) {
                            //出库任务完成，修改状态为容器到达，定时任务生成播种波次
                            taskStsType = TaskStsType.WCS_EXECUTE_OUT_TASK_DONE;
                        } else {
                            String errMsg = "任务编号：" + task.getTaskNo() + "状态为不匹配，" + "不能执行：" + TaskStsType.WCS_EXECUTE_OUT_TASK_DONE.desc + "任务";
                            log.error(errMsg);
                            throw new CoolException(errMsg);
                        }
                    }

                    //更新出库状态及相关字段
                    boolean update = taskService.update(new LambdaUpdateWrapper<Task>()
                            .set(Task::getRobotCode, callbackParam.getRobotCode())
                            .set(Task::getSysTaskCode, callbackParam.getSysTaskCode())
                            .set(Task::getTaskSts, taskStsType.id)
                            .set(Task::getExcudeStatus, callbackParam.getStatus())
                            .set(Task::getTaskDesc, callbackParam.getMessage())
                            .eq(Task::getBarcode, callbackParam.getContainerCode())
                            .eq(Task::getTaskNo, callbackParam.getTaskCode()));

                    if (!update) {
                        throw new CoolException("任务更新失败！！");
                    }

                }

            });
        } else {
            throw new CoolException("更新内容不存在！！");
        }
    }

    /**
     * 容器流动通知
     *
     * @param code
     * @return
     */
    @Override
    public synchronized R containerConveryor(String code) {
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>().eq(Task::getBarcode, code));
        if (tasks.isEmpty()) {
            return R.error("容器码任务不存在！！");
        } else if (tasks.size() > 1) {
            return R.error("容器码任务错误！！");
        }
        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) {
            //流动通知下发完成后，修改任务状态为输送线流动中。。
            //TODO 判断任务是否为103拣料出库，103拣料流动后修改为4（RCS容器流动任务已下发）
            if (task.getTaskType() == 103) {
                //TODO 需找海柔确认是否需要重新调用入库接口
                //更新库存信息,修改任务状态为4 （RCS容器流动任务已下发）
                workService.pickTask(task.getId());
//                taskService.update(new LambdaUpdateWrapper<Task>().eq(Task::getId, task.getId()).set(Task::getTaskSts, TaskStsType.WCS_CONVEYOR_START))
            } else {
                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()));
//            }
        });
        return R.ok();
    }


    @Override
    public R rfidCallback(RfidSingalRequest request) {
        return null;
    }

    @Override
    public R getPlatforms() {
        return R.ok(platformService.list(new LambdaQueryWrapper<>()));
    }

    /**
     * 拍灯拣料逻辑，详细说明见接口调用说明
     *
     * @param request
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public void slapLightLogic(Map<String, Object> request) {
        String taskNo = request.get("taskNo").toString();
        String orderNo = request.get("orderNo").toString();

        List<CacheSite> performs = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getOrderNo, orderNo));
        if (Objects.isNull(performs.stream().findFirst().get().getPlatformId())) {
            throw new CoolException("请打印明细，并绑定目标集货区");
        }

        //* 1. 判断当前容器是否还有物料未拣，未拣完闪灯，拣完通知容器流动，并灭灯
        SlapLightControlParam slapParam = new SlapLightControlParam();
        MultiValueMap<String, Object> params = new LinkedMultiValueMap<>();
        //默认流动
        boolean converyor = false;
        //判断当前任务是否还有物料未拣
        if (!checked(orderNo, taskNo)) {
            //调用三方接口,闪灯不做操作
            // 设置请求参数
            params.add("params", JSONObject.toJSONString(slapParam));
            log.info("请求地址：{}，请求参数：{}", SystemProperties.SLAP_LIGHT, JSONObject.toJSONString(slapParam));
        } else {
            //调用三方接口,灭灯通知容器流动， 传灭灯参数
            //todo 判断当前订单是否完成，完成灭灯，未完成保持拣货状态亮灯
            Order one = orderService.getOne(new LambdaQueryWrapper<Order>().eq(Order::getOrderNo, orderNo));

            if (Objects.isNull(one)) {
                throw new CoolException("当前订单明细不存在！！");
            }
//            //获取播种已完成的订单明细
//            List<OrderDetl> detlList = orderDetls.stream().filter(detl -> {
//                return detl.getPickStatus() == OrderPickStatus.ORDER_PICK_STATUS_DONE.val;
//            }).collect(Collectors.toList());

            //判断数量是否与订单明细的需求量相同，相同则订单完成
            if (one.getPickStatus() == OrderPickStatus.ORDER_PICK_STATUS_DONE.val) {
                //播种完成，释放绑定站点
                List<CacheSite> cacheSites = cacheSiteService.list(new LambdaQueryWrapper<CacheSite>().eq(CacheSite::getOrderNo, orderNo));
                for (CacheSite cacheSite : cacheSites) {
                    if (!cacheSite.getSiteStatus().equals(CacheSiteStatusType.O.id)) {
                        cacheSite.setSiteStatus(CacheSiteStatusType.O.id);
                        cacheSite.setOrderId(null);
                        cacheSite.setBarcode(null);
                        cacheSite.setOrderNo(null);
                        cacheSite.setPlatformId(null);
                        cacheSite.setPlatformNo(null);
                        cacheSite.setUpdateTime(new Date());
                        if (!cacheSiteService.updateById(cacheSite)) {
                            throw new CoolException("播种站点更新失败");
                        }
                    }
                }
            }
            converyor = true;
            params.add("params", JSONObject.toJSONString(slapParam));
            log.info("请求地址：{}，请求参数：{}", SystemProperties.SLAP_LIGHT, JSONObject.toJSONString(slapParam));
        }

        if (converyor) {
            Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskNo, request.get("taskNo")));
            if (Objects.isNull(task)) {
                throw new CoolException("任务不存在！！");
            }
            containerConveryor(task.getBarcode());
        }

//        HttpHeaders headers = new HttpHeaders();
//        headers.add("Content-Type", "application/json");
//        HttpEntity httpEntity = new HttpEntity<>(params, headers);
//        // 请求
//        ResponseEntity<CommonReponse> exchange = restTemplate.exchange(SystemProperties.CONVEYOR_START, HttpMethod.POST, httpEntity, CommonReponse.class);
//        log.info("下发流动通知 返回结果：{}", exchange);
//        if (exchange.getBody() == null) {
//            throw new CoolException("下发流动通知失败！！");
//        } else {
//            CommonReponse response = exchange.getBody();
//            if (response.getCode() == 0) {
//                if (!converyor) {
//                    //* 2. 容器流动判断，如果料箱没有物料 code传200， 有物料传100 执行回库任务,修改任务状态为  调用containerConveryor（taskNo）方法
//                    containerConveryor(request.get("taskNo").toString());
//                }
//            }
//        }
    }

    /**
     * 判断当前任务下，订单是否已完成拣货
     *
     * @param orderNo
     * @param taskNo
     * @return
     */
    public synchronized boolean checked(String orderNo, String taskNo) {
        if (Objects.isNull(orderNo)) {
            throw new CoolException("订单编码不能为空！！");
        }
        if (Objects.isNull(taskNo)) {
            throw new CoolException("任务编码不能为空！！");
        }

        List<TaskDetl> taskDetls = taskDetlService.list(new LambdaQueryWrapper<TaskDetl>().eq(TaskDetl::getTaskNo, taskNo));
        if (taskDetls.isEmpty()) {
            throw new CoolException("订单明细不存在！！");
        }

        List<Long> detlIds = taskDetls.stream().map(TaskDetl::getId).collect(Collectors.toList());

        double taskNum = taskDetls.stream().mapToDouble(TaskDetl::getAnfme).sum();

        List<WaveSeed> seeds = waveSeedService.list(new LambdaQueryWrapper<WaveSeed>().in(WaveSeed::getTaskDetlId, detlIds));
        if (seeds.isEmpty()) {
            throw new CoolException("播种信息不存在！！！");
        }
        double seedNum = seeds.stream().mapToDouble(WaveSeed::getWorkQty).sum();
        //判断任务需求总量是否等播种总数量
        if (taskNum == seedNum) {
            return true;
        } else  {
            return false;
        }
    }

}