package com.zy.asrs.wcs.rcs.thread;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.asrs.framework.common.Cools;
import com.zy.asrs.framework.exception.CoolException;
import com.zy.asrs.wcs.asrs.entity.param.FlowLogicCodeParam;
import com.zy.asrs.wcs.core.domain.dto.MotionDto;
import com.zy.asrs.wcs.core.entity.Motion;
import com.zy.asrs.wcs.core.entity.Task;
import com.zy.asrs.wcs.core.kernel.KernelService;
import com.zy.asrs.wcs.core.service.TaskService;
import com.zy.asrs.wcs.core.utils.RedisUtil;
import com.zy.asrs.wcs.core.utils.ShuttleDispatcher;
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.protocol.LiftProtocol;
import com.zy.asrs.wcs.rcs.model.protocol.ShuttleProtocol;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.codec.digest.Md5Crypt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

@Component
public class FlowExecute {

    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private TaskService taskService;
    @Autowired
    private ShuttleDispatcher shuttleDispatcher;
    @Autowired
    private KernelService kernelService;

    //执行流程图
    public boolean execute(List<JSONObject> list) {
        String currentId = list.get(0).getString("id");

        JSONObject devpType = list.get(0).getJSONObject("data").getJSONObject("devpType");
        String staNo = devpType.getString("staNo");
        //搜索工作档
        List<Task> tasks = taskService.list(new LambdaQueryWrapper<Task>()
                .eq(Task::getOriginSite, staNo)
                .eq(Task::getStatus, 1));

        for (Task task : tasks) {
            String redisKey = DigestUtils.md5Hex(JSON.toJSONString(list));

            redisSet(redisKey, "motionList", new ArrayList<Motion>());
            while (currentId != null) {
                //获取流程图
                JSONObject flow = findFLow(list, currentId);
                if (flow == null) {
                    break;
                }

                //执行
                boolean result = executeFlow(task, flow, redisKey);

                //执行后续流程
                if (Cools.isEmpty(flow.get("nextTrue")) && Cools.isEmpty(flow.get("nextFalse"))) {
                    break;//无后续流程
                }

                //更新id
                currentId = result ? flow.getString("nextTrue") : flow.getString("nextFalse");
            }

            System.out.println("执行完成");
            redisUtil.del(redisKey);//释放缓存
        }
        return true;
    }

    private boolean executeFlow(Task task, JSONObject flow, String redisKey) {
        System.out.println(flow.getString("id") + "被执行");
        JSONObject data = flow.getJSONObject("data");
        String type = data.getString("type");
        boolean result = false;
        if (type.equals("devp")) {
            result = executeDevpFlow(task, data, redisKey);
        } else if (type.equals("shuttle")) {
            result = executeShuttleFlow(task, data, redisKey);
        } else if (type.equals("lift")) {
            result = executeLiftFlow(task, data, redisKey);
        }
        return result;
    }

    private JSONObject findFLow(List<JSONObject> list, String id) {
        for (JSONObject flow : list) {
            if (flow.getString("id").equals(id)) {
                return flow;
            }
        }
        return null;
    }

    private boolean executeDevpFlow(Task task, JSONObject data, String redisKey) {
        JSONObject devpType = data.getJSONObject("devpType");
        String staNo = devpType.getString("staNo");
        //搜索工作

        return true;
    }

    private boolean executeShuttleFlow(Task task, JSONObject data, String redisKey) {
        JSONObject shuttleType = data.getJSONObject("shuttleType");
        String oper = shuttleType.getString("shuttleOper");
        if (oper.equals("searchIdleShuttle")) {
            //搜索空闲车
            ShuttleThread shuttleThread = shuttleDispatcher.searchIdleShuttle(task);
            if (shuttleThread == null) {
                throw new CoolException("穿梭车不存在");
            }
            //存入缓存
            redisSet(redisKey, "shuttleDevice", shuttleThread.getDevice());
            return true;
        } else if (oper.equals("judgeShuttleCurrentTaskLev")) {
            //判断小车是否在任务楼层
            //取出缓存小车
            Object shuttleDeviceObj = redisGet(redisKey, "shuttleDevice");
            if (shuttleDeviceObj == null) {
                throw new CoolException("穿梭车缓存为空");
            }
            Device device = JSON.parseObject(String.valueOf(shuttleDeviceObj), Device.class);
            if (device == null) {
                throw new CoolException("穿梭车设备不存在");
            }

            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getId().intValue());
            if (shuttleThread == null) {
                throw new CoolException("穿梭车不存在");
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                throw new CoolException("穿梭车不存在");
            }

            //小车坐标
            String shuttleLocNo = shuttleProtocol.getCurrentLocNo();
            String taskLocNo = null;
            if (task.getTaskSts() < 100) {
                taskLocNo = task.getDestLoc();
            } else if (task.getTaskSts() > 100 && task.getTaskSts() < 200) {
                taskLocNo = task.getOriginLoc();
            }

            // 小车和任务楼层一致
            if (Utils.getLev(shuttleLocNo) == Utils.getLev(taskLocNo)) {
                return true;
            }else {
                return false;
            }
        }

        return true;
    }

    private boolean executeLiftFlow(Task task, JSONObject data, String redisKey) {
        Object object = redisGet(redisKey, "motionList");
        List<Motion> motionList = JSON.parseArray(JSON.toJSONString(object), Motion.class);

        Object liftDeviceObj = redisGet(redisKey, "liftDevice");
        if (liftDeviceObj == null) {
            throw new CoolException("提升机缓存为空");
        }

        Device device = JSON.parseObject(String.valueOf(liftDeviceObj), Device.class);
        if (device == null) {
            throw new CoolException("提升机设备不存在");
        }

        LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, device.getId().intValue());
        if (liftThread == null) {
            throw new CoolException("提升机不存在");
        }

        LiftProtocol liftProtocol = liftThread.getStatus();
        if (liftProtocol == null) {
            throw new CoolException("提升机不存在");
        }

        JSONObject liftType = data.getJSONObject("liftType");
        String opera = liftType.getString("liftOper");
        if (opera.equals("move")) {
            //提升机升降
            String sourceLevStr = liftType.getString("sourceLev");
            String targetLevStr = liftType.getString("targetLev");
            Integer sourceLev = getLiftOperaLev(sourceLevStr, task, redisKey);
            Integer targetLev = getLiftOperaLev(targetLevStr, task, redisKey);

            motionList.addAll(kernelService.liftMove(
                    MotionDto.build((dto -> {
                        dto.setLiftNo(device.getId().intValue());
                        dto.setLev(sourceLev);
                    }))
                    , MotionDto.build((dto -> {
                        dto.setLiftNo(device.getId().intValue());
                        dto.setLev(targetLev);
                    }))
            ));
        }

        return true;
    }

    private Integer getLiftOperaLev(String opera, Task task, String redisKey) {
        if (opera.equals("sourceLev")) {
            return Utils.getLev(task.getOriginLoc());
        } else if (opera.equals("targetLev")) {
            return Utils.getLev(task.getDestLoc());
        } else if (opera.equals("shuttleLev")) {
            //取出缓存小车
            Object shuttleDeviceObj = redisGet(redisKey, "shuttleDevice");
            if (shuttleDeviceObj == null) {
                throw new CoolException("穿梭车缓存为空");
            }
            Device device = JSON.parseObject(String.valueOf(shuttleDeviceObj), Device.class);
            if (device == null) {
                throw new CoolException("穿梭车设备不存在");
            }

            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getId().intValue());
            if (shuttleThread == null) {
                throw new CoolException("穿梭车不存在");
            }

            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                throw new CoolException("穿梭车不存在");
            }

            return Utils.getLev(shuttleProtocol.getCurrentLocNo());
        }

        throw new CoolException("类型异常");
    }

    private boolean redisSet(String redisKey, String key, Object data) {
        if (redisUtil.hasKey(redisKey)) {
            Object obj = redisUtil.get(redisKey);
            JSONObject object = JSON.parseObject(String.valueOf(obj));
            object.put(key, data);
            redisUtil.set(redisKey, JSON.toJSONString(object));
        } else {
            JSONObject object = new JSONObject();
            object.put(key, data);
            redisUtil.set(redisKey, JSON.toJSONString(object));
        }
        return true;
    }

    private Object redisGet(String redisKey, String key) {
        if (redisUtil.hasKey(redisKey)) {
            Object obj = redisUtil.get(redisKey);
            JSONObject object = JSON.parseObject(String.valueOf(obj));
            if (!object.containsKey(key)) {
                return null;
            }
            return object.get(key);
        }
        return null;
    }

//    private boolean executeFlow(List<Map<String, Object>> list) {
//        for (Map<String, Object> map : list) {
//            JSONObject data = (JSONObject) map.get("data");
//            if (data.getString("type").equals("devp")) {
//                JSONObject devp = data.getJSONObject("devpType");
//                String devpNo = devp.getString("devpNo");//输送线PLC
//                String staNo = devp.getString("staNo");//站号
//                Boolean enableStaStatus = devp.getBoolean("enableStaStatus");//判断站点状态
//                JSONArray staStatus = devp.getJSONArray("staStatus");//站点状态列表
//                String staJudgementFailExecute = devp.getString("staJudgementFailExecute");//判断失败后是否继续执行流程
//                Boolean writeWorkNoStatus = devp.getBoolean("writeWorkNoStatus");//是否写入工作号
//                Boolean writeStaNoStatus = devp.getBoolean("writeStaNoStatus");//是否写入目标站
//                String writeWorkNo = devp.getString("writeWorkNo");//写入工作号数据
//                String writeStaNo = devp.getString("writeStaNo");//写入目标站数据
//                if (enableStaStatus) {
//                    //判断站点状态
//                    boolean statusFlag = true;//默认判断通过
//                    for (Object status : staStatus) {
//                        System.out.println(status);
//                    }
//
//                    if (!statusFlag) {
//                        //判断不通过
//                        if (staJudgementFailExecute.equals("stop")) {
//                            //判断失败后不继续执行
//                            return false;
//                        }
//                    }
//
//                }
//
//                if (writeWorkNoStatus) {
//                    //写入工作号
//                }
//
//                if (writeStaNoStatus) {
//                    //写入目标站
//                }
//                System.out.println(devp);
//            }
//            System.out.println(data);
//        }
//
//        System.out.println(list);
//        return false;
//    }

}