package com.zy.asrs.wcs.core.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.common.utils.HttpHandler;
import com.zy.asrs.framework.common.Cools;
import com.zy.asrs.framework.common.R;
import com.zy.asrs.framework.common.SnowflakeIdWorker;
import com.zy.asrs.wcs.core.domain.dto.BasLiftStaDto;
import com.zy.asrs.wcs.core.domain.param.*;
import com.zy.asrs.wcs.core.entity.*;
import com.zy.asrs.wcs.core.model.enums.DeviceCtgType;
import com.zy.asrs.wcs.core.model.enums.TaskCtgType;
import com.zy.asrs.wcs.core.model.enums.TaskStsType;
import com.zy.asrs.wcs.core.service.*;
import com.zy.asrs.wcs.core.utils.Utils;
import com.zy.asrs.wcs.rcs.cache.SlaveConnection;
import com.zy.asrs.wcs.rcs.entity.Device;
import com.zy.asrs.wcs.rcs.model.enums.SlaveType;
import com.zy.asrs.wcs.rcs.model.enums.WorkModeType;
import com.zy.asrs.wcs.rcs.model.protocol.ShuttleProtocol;
import com.zy.asrs.wcs.rcs.service.DeviceService;
import com.zy.asrs.wcs.rcs.thread.DevpThread;
import com.zy.asrs.wcs.rcs.thread.ShuttleThread;
import com.zy.asrs.wcs.system.controller.BaseController;
import com.zy.asrs.wcs.system.entity.Dict;
import com.zy.asrs.wcs.system.service.DictService;
import org.apache.poi.ss.formula.functions.T;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 对外暴露接口
 * 提供任务生成、设备运动等接口
 */
@RestController
@RequestMapping("/openapi")
public class OpenController extends BaseController {

    private static final Logger log = LoggerFactory.getLogger(OpenController.class);
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private TaskCtgService taskCtgService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private DeviceService deviceService;
    @Autowired
    private LocService locService;
    @Autowired
    private DictService dictService;
    @Autowired
    private BasConveyorPathService basConveyorPathService;
    @Autowired
    private BasLiftService basLiftService;
    @Autowired
    private BasConveyorService basConveyorService;
    @Autowired
    private BasConveyorStaService basConveyorStaService;
    @Autowired
    private OpenService openService;


    @PostMapping("/agvPickupComplete")
    public Map<String, Object> agvPickupComplete(@RequestBody AgvTaskParam agvTaskParam) {
        HashMap<String, String> mesMap = new HashMap<>();
        mesMap.put("taskNo", agvTaskParam.getRobotTaskCode());
        mesMap.put("contNo",agvTaskParam.getExtra().getValues().getCarrierCode());
        boolean returnTask3 = toMesHttpRequest(mesMap, "172.18.231.126", "/api/wcs/wcsTaskInfo", "3",agvTaskParam.getExtra().getValues().getSlotName());

        HashMap<String, Object> map = new HashMap<>();
        map.put("code","0");
        map.put("message","成功");
        map.put("reqCode", "");
        log.info("agv请求取货完成，wms任务号:"+JSON.toJSONString(agvTaskParam));
        return map;

    }

    @PostMapping("/agvTaskComplete")
    public Map<String, Object> agvTaskComplete(@RequestBody AgvTaskParam agvTaskParam) {
        log.info("agv请求任务完成，wms任务号:"+JSON.toJSONString(agvTaskParam));
        HashMap<String, Object> map = new HashMap<>();
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getWmsTaskNo, agvTaskParam.getRobotTaskCode()));
        if (!Cools.isEmpty(task)){
            if (agvTaskParam.getExtra().getValues().getSlotName().equals("06YZ0001")){
                Device device = deviceService.getOne(new LambdaQueryWrapper<Device>()
                        .eq(Device::getDeviceType, DeviceCtgType.CONVEYOR.val())
                        .eq(Device::getStatus, 1)
                        .eq(Device::getDeviceNo, 1));
                if (device == null) {
                    map.put("code","1");
                    map.put("message","失败，设备不存在");
                    map.put("reqCode", "");
                    return map;
                }

                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Conveyor, device.getId().intValue());
                if (devpThread == null) {
                    map.put("code","1");
                    map.put("message","失败，输送线不在线");
                    map.put("reqCode", "");
                    return map;
                }
                boolean result = devpThread.writeWorkSta(100, Short.parseShort("9999"), (short) 101);
                if (!result) {
                    map.put("code","1");
                    map.put("message","失败，输送线命令下发失败");
                    map.put("reqCode", "");
                    return map;
                }
            }else {
                if (task.getTaskSts() == 1000 && task.getMemo().equals(agvTaskParam.getExtra().getValues().getSlotName())){
                    HashMap<String, String> mesMap = new HashMap<>();
                    mesMap.put("taskNo", agvTaskParam.getRobotTaskCode());
                    mesMap.put("contNo",agvTaskParam.getExtra().getValues().getCarrierCode());
                    boolean returnTask4 = toMesHttpRequest(mesMap, "172.18.231.126", "/api/wcs/wcsTaskInfo", "4",agvTaskParam.getExtra().getValues().getSlotName());
                    if (returnTask4){
                        task.setTaskSts(1001L);
                        taskService.updateById(task);
                        log.info("出库任务完成推送mes"+task.getWmsTaskNo());
                    }else {
                        log.error("出库任务完成推送mes失败"+task.getWmsTaskNo());
                    }

                }
            }
        }else {
            HashMap<String, String> mesMap = new HashMap<>();
            mesMap.put("taskNo", agvTaskParam.getRobotTaskCode());
            mesMap.put("contNo",agvTaskParam.getExtra().getValues().getCarrierCode());
            boolean returnTask4 = toMesHttpRequest(mesMap, "172.18.231.126", "/api/wcs/wcsTaskInfo", "4",agvTaskParam.getExtra().getValues().getSlotName());
            if (returnTask4){
                log.info("出库任务完成推送mes"+agvTaskParam.getRobotTaskCode());
            }else {
                log.error("出库任务完成推送mes失败"+agvTaskParam.getRobotTaskCode());
            }
        }

        map.put("code","0");
        map.put("message","成功");
        map.put("reqCode", "");
        return map;
    }

    private boolean toMesHttpRequest(Map<String,String> map, String url, String path, String code,String location){
        Date now = new Date();
        long time = now.getTime()/1000;
        ReturnWcsTaskStatisParam returnWcsTaskStatisParam = new ReturnWcsTaskStatisParam();
        returnWcsTaskStatisParam.setRequestPK(map.get("taskNo"));
        returnWcsTaskStatisParam.setTrkId(map.get("taskNo"));
        returnWcsTaskStatisParam.setContNo(map.get("contNo"));
        returnWcsTaskStatisParam.setCode(code);
        returnWcsTaskStatisParam.setOperator("wcs");
        returnWcsTaskStatisParam.setOperationTime(time);
        returnWcsTaskStatisParam.setTrkType("01");
        returnWcsTaskStatisParam.setCurPos(location);
        String response = "";
        boolean success = false;
        try {
            response = new HttpHandler.Builder()
                    .setUri(url)
                    .setPath(path)
                    .setJson(JSONObject.toJSONString(returnWcsTaskStatisParam))
                    .build()
                    .doPost();
            JSONObject jsonObject = JSON.parseObject(response);

            String code1 = jsonObject.get("success").toString();
            log.info("上报mes接口请求体:"+JSON.toJSONString(returnWcsTaskStatisParam) +",返回值:"+jsonObject.toJSONString());
            if(code1.equals("1")){
                success = true;
            }
        }catch (Exception e){
            return success;
        }
        return success;
    }


    //取消wcs任务
    @PostMapping("/cancelWcsTask")
    public HashMap<String,Object> cancelWcsTask(@RequestBody CreateWcsTaskParam param){
        HashMap<String, Object> map = new HashMap<>();
        if (Cools.isEmpty(param)){
            map.put("success", "0");
            map.put("message", "失败，请求参数为空");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
            return map;
        }
        if (Cools.isEmpty(param.getRequestPK()) || Cools.isEmpty(param.getContNo()) ){
            map.put("success", "0");
            map.put("message", "失败，请求参数为空");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
            return map;
        }
        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskNo, param.getRequestPK()).eq(Task::getHostId,1L));
        if (task == null){
            map.put("success", "0");
            map.put("message", "失败，未找到相同编号的任务");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
            return map;
        }
        if (task.getTaskSts() == 1 || task.getTaskSts() == 101){
            boolean remove = false;
            try {
                remove = taskService.removeById(task);
            }catch (Exception e){
                map.put("success", "0");
                map.put("message", "取消任务失败:"+e.getMessage());
                map.put("result", "");
                map.put("requestPK",param.getRequestPK());
                return map;
            }finally {
                if (remove){
                    map.put("success", "1");
                    map.put("message", "取消任务成功");
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                }else {
                    map.put("success", "0");
                    map.put("message", "取消任务失败");
                    map.put("result", "");
                    map.put("requestPK", param.getRequestPK());
                }
            }
        }else {
            map.put("success", "0");
            map.put("message", "失败，任务已执行");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
            return map;
        }
        return map;

    }


    //mes下发任务
    @PostMapping("/createWcsTask")
    public HashMap<String,Object> createWcsTask(@RequestBody CreateWcsTaskParam param){
        log.info("mes任务下发，请求体:"+JSONObject.toJSONString(param));
        HashMap<String, Object> map = new HashMap<>();
        if (Cools.isEmpty(param)){
            map.put("success", "0");
            map.put("message", "失败，请求参数为空");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
            log.info("返回mes信息:"+JSONObject.toJSONString(map));
            return map;
        }
        if (Cools.isEmpty(param.getRequestPK()) || Cools.isEmpty(param.getContNo()) || Cools.isEmpty(param.getTrkPrty()) || Cools.isEmpty(param.getToPos())){
            map.put("success", "0");
            map.put("message", "失败，请求参数为空");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
            log.info("返回mes信息:"+JSONObject.toJSONString(map));
            return map;
        }

        Task task = taskService.getOne(new LambdaQueryWrapper<Task>().eq(Task::getTaskNo, param.getRequestPK()).eq(Task::getHostId,1L));
        if(task != null){
            map.put("success", "0");
            map.put("message", "失败，存在相同编号的任务");
            map.put("result", "");
            map.put("requestPK", param.getRequestPK());
            log.info("返回mes信息:"+JSONObject.toJSONString(map));
            return map;
        }

        map = openService.createWcsTaskCache(param);
        log.info("返回mes信息:"+JSONObject.toJSONString(map));
        return map;
    }

    //生成入库任务
    @PostMapping("/createInTask")
    public R createInTask(@RequestBody CreateInTaskParam param) {
        return openService.createInTask(param, null);
    }

    //生成出库任务
    @PostMapping("/createOutTask")
    public R createOutTask(@RequestBody CreateOutTaskParam param) {
        return openService.createOutTask(param, null);
    }

    //生成手动取放货任务
    @PostMapping("/createManualTakeTask")
    public R createManualTakeTask(@RequestBody CreateManualTakeTaskParam param) {
        //获取手动任务类型
        TaskCtg taskCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
                .eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.MANUAL))
                .eq(TaskCtg::getStatus, 1));
        if (taskCtg == null) {
            return R.error("任务类型异常");
        }

        Task one = taskService.getOne(new LambdaQueryWrapper<Task>()
                .eq(Task::getTaskCtg, taskCtg.getId())
                .eq(Task::getOriginLoc, param.getOriginLoc())
                .eq(Task::getDestLoc, param.getDestLoc()));
        if (one != null) {
            return R.error("任务已存在");
        }

        //优先级
        Integer priority = 10;
        if (param.getPriority() != null) {
            priority = param.getPriority();
        }

        Task task = new Task();
        task.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
        task.setTaskNo(String.valueOf(Utils.getTaskNo("OUT")));
        task.setWmsTaskNo(param.getTaskNo());
        task.setTaskSts(TaskStsType.NEW_MANUAL.sts);
        task.setTaskCtg(taskCtg.getId());
        task.setPriority(priority);
        task.setOriginSite(null);
        task.setOriginLoc(param.getOriginLoc());//源库位
        task.setDestSite(null);
        task.setDestLoc(param.getDestLoc());//目标库位
        task.setIoTime(new Date());
        task.setStartTime(new Date());
        task.setStatus(1);
        task.setMemo("");
        task.setShuttleNo(null);//等待主线程分配小车
        task.setRecordLoc(param.getRecord() ? "Y" : "N");//记录库存信息
        task.setHostId(1L);//临时控制只允许host为1

        boolean result = taskService.save(task);
        if (!result) {
            return R.error("生成手动取放货任务失败！");
        }
        return R.ok();
    }

    //生成载货移动任务
    @PostMapping("/createLadenMoveTakeTask")
    public R createLadenMoveTakeTask(@RequestBody CreateManualTakeTaskParam param) {
        //获取手动任务类型
        TaskCtg taskCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
                .eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.MOVE))
                .eq(TaskCtg::getStatus, 1));
        if (taskCtg == null) {
            return R.error("任务类型异常");
        }

        Task one = taskService.getOne(new LambdaQueryWrapper<Task>()
                .eq(Task::getTaskCtg, taskCtg.getId())
                .eq(Task::getOriginLoc, param.getOriginLoc())
                .eq(Task::getDestLoc, param.getDestLoc()));
        if (one != null) {
            return R.error("任务已存在");
        }

        //优先级
        Integer priority = 10;
        if (param.getPriority() != null) {
            priority = param.getPriority();
        }

        Task task = new Task();
        task.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
        task.setTaskNo(String.valueOf(Utils.getTaskNo("OUT")));
        task.setWmsTaskNo(param.getTaskNo());
        task.setTaskSts(TaskStsType.NEW_LADEN_MOVE.sts);
        task.setTaskCtg(taskCtg.getId());
        task.setPriority(priority);
        task.setOriginSite(null);
        task.setOriginLoc(param.getOriginLoc());//源库位
        task.setDestSite(null);
        task.setDestLoc(param.getDestLoc());//目标库位
        task.setIoTime(new Date());
        task.setStartTime(new Date());
        task.setStatus(1);
        task.setMemo("");
        task.setShuttleNo(null);//等待主线程分配小车
        task.setRecordLoc(param.getRecord() ? "Y" : "N");//记录库存信息
        task.setHostId(1L);//临时控制只允许host为1

        boolean result = taskService.save(task);
        if (!result) {
            return R.error("生成手动取放货任务失败！");
        }
        return R.ok();
    }

    //生成小车移动任务
    @PostMapping("/createMoveTask")
    public R createMoveTask(@RequestBody CreateMoveTaskParam param) {
        //获取出库任务类型
        TaskCtg taskCtg = taskCtgService.getOne(new LambdaQueryWrapper<TaskCtg>()
                .eq(TaskCtg::getFlag, String.valueOf(TaskCtgType.MOVE))
                .eq(TaskCtg::getStatus, 1));
        if (taskCtg == null) {
            return R.error("任务类型异常");
        }

        Device device = deviceService.getOne(new LambdaQueryWrapper<Device>()
                .eq(Device::getDeviceType, DeviceCtgType.SHUTTLE.val())
                .eq(Device::getDeviceNo, param.getShuttleNo())
                .eq(Device::getHostId, 1)
                .eq(Device::getStatus, 1));
        if (device == null) {
            return R.error("穿梭车不存在");
        }
        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getId().intValue());
        if (shuttleThread == null) {
            return R.error("穿梭车不在线");
        }
        ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
        if (shuttleProtocol == null) {
            return R.error("穿梭车不在线");
        }
//        if (Utils.getLev(shuttleProtocol.getCurrentLocNo()) != Utils.getLev(param.getDestLoc())) {
//            return R.error("穿梭车和目标位置不在同一楼层");
//        }

        Task one = taskService.getOne(new LambdaQueryWrapper<Task>()
                .eq(Task::getTaskCtg, taskCtg.getId())
                .eq(Task::getDestLoc, param.getDestLoc()));
        if (one != null) {
            return R.error("任务已存在");
        }

        //优先级
        Integer priority = 10;
        if (param.getPriority() != null) {
            priority = param.getPriority();
        }

        Task task = new Task();
        task.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
        task.setTaskNo(String.valueOf(Utils.getTaskNo("OUT")));
        task.setWmsTaskNo(param.getTaskNo());
        task.setTaskSts(TaskStsType.NEW_MOVE.sts);
        task.setTaskCtg(taskCtg.getId());
        task.setPriority(priority);
        task.setOriginSite(null);
        task.setOriginLoc(null);
        task.setDestSite(null);
        task.setDestLoc(param.getDestLoc());
        task.setIoTime(new Date());
        task.setStartTime(new Date());
        task.setStatus(1);
        task.setMemo("");
        task.setShuttleNo(param.getShuttleNo());
        task.setRecordLoc("N");//不记录库存信息
        task.setHostId(1L);//临时控制只允许host为1

        boolean result = taskService.save(task);
        if (!result) {
            return R.error("生成小车移动任务失败！");
        }
        return R.ok();
    }

    //切换工作模式
    @PostMapping("/switchWorkMode")
    public R switchWorkMode(@RequestBody SwitchWorkModeParam param) {
        BasConveyor basConveyor = basConveyorService.getOne(new LambdaQueryWrapper<BasConveyor>().eq(BasConveyor::getConveyorNo, param.getConveyorNo()));
        if(basConveyor == null) {
            return R.error("输送线不存在");
        }

        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Conveyor, basConveyor.getDeviceId().intValue());
        if(devpThread == null) {
            return R.error("输送线线程不存在");
        }

        boolean result = devpThread.switchWorkMode(param.getSiteId(), param.getWorkMode());
        if (!result) {
            return R.error("模式切换失败");
        }
        return R.ok();
    }

}