package com.zy.core.thread;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.core.common.DateUtils;
import com.core.common.SpringUtils;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.*;

import com.zy.common.utils.*;
import com.zy.core.News;
import com.zy.core.ThreadHandler;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.OutputQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
import com.zy.core.model.ShuttleSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.NyShuttleHttpCommand;
import com.zy.core.model.command.ShuttleAssignCommand;
import com.zy.core.model.command.ShuttleCommand;
import com.zy.core.model.command.ShuttleRedisCommand;
import com.zy.core.model.protocol.LiftProtocol;
import com.zy.core.model.protocol.NyShuttleProtocol;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 牛眼四向穿梭车线程
 */
@Data
@Slf4j
public class NyShuttleThread implements  Runnable, ThreadHandler {

    private ShuttleSlave slave;
    private NyShuttleProtocol shuttleProtocol;
    private RedisUtil redisUtil;

    public NyShuttleThread(ShuttleSlave slave,RedisUtil redisUtil) {
        this.slave = slave;
        this.redisUtil = redisUtil;
    }

    @Override
    public void run() {
        this.connect();
        while (true) {
            try {
                int step = 1;
                Task task = MessageQueue.poll(SlaveType.Shuttle, slave.getId());
                if (task != null) {
                    step = task.getStep();
                }
                switch (step) {
                    // 读数据
                    case 1:
                        read();
                        break;
                    // 写入数据
                    case 2:
                        write((NyShuttleHttpCommand) task.getData());
                        break;
                    //下发任务
                    case 3:
                        assignWork((ShuttleAssignCommand) task.getData());
                        break;
                    default:
                        break;
                }
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void read() {
        try {
            readStatus();
            //四向穿梭车空闲、有任务、标记为true、存在任务指令，需要执行任务的下一条指令
            if (shuttleProtocol.getFree() == ShuttleStatusType.IDLE.id
                    && shuttleProtocol.getTaskNo() != 0
                    && shuttleProtocol.getPakMk()) {
                //执行下一步指令
                executeWork(shuttleProtocol.getTaskNo().shortValue());
            }
        } catch (Exception e) {
            e.printStackTrace();
            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
        }
    }

    private void readStatus() {
        try {
            if (null == shuttleProtocol) {
                shuttleProtocol = new NyShuttleProtocol();
                shuttleProtocol.setShuttleNo(slave.getId().shortValue());
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
            }

            //----------读取四向穿梭车状态-----------
            NyShuttleHttpCommand readStatusCommand = NyHttpUtils.getReadStatusCommand(slave.getId());
            JSONObject jsonObject = NyHttpUtils.requestCommand(readStatusCommand);
            if (jsonObject == null) {
                OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            }else {
                //手动状态/自动状态
                shuttleProtocol.setWorkingMode(jsonObject.getInteger("workingMode"));
                //允许状态 0:运行中1：空闲
                shuttleProtocol.setFree(jsonObject.getInteger("free"));
                //当前速度
                shuttleProtocol.setSpeed(jsonObject.getInteger("speed"));
                //负载状态
                shuttleProtocol.setLoadState(jsonObject.getInteger("loadState"));
                //管制状态
                shuttleProtocol.setSuspendState(jsonObject.getInteger("suspendState"));
                //顶升位置
                shuttleProtocol.setLiftPosition(jsonObject.getInteger("liftPosition"));
                //运行方向
                shuttleProtocol.setRunDir(jsonObject.getInteger("runDir"));
                //运行方向
                shuttleProtocol.setRunDir2(jsonObject.getInteger("runDir2"));
                //充电状态
                shuttleProtocol.setChargState(jsonObject.getInteger("chargState"));
                //电池电量
                shuttleProtocol.setPowerPercent(jsonObject.getInteger("powerPercent"));
                //最高电芯电压(mV)
                shuttleProtocol.setMaxCellVoltage(jsonObject.getInteger("maxCellVoltage"));
                //最低电芯电压(mV)
                shuttleProtocol.setMinCellVoltage(jsonObject.getInteger("minCellVoltage"));
                //电池电压
                shuttleProtocol.setVoltage(jsonObject.getInteger("voltage"));
                //充放电循环次数
                shuttleProtocol.setChargeCycleTimes(jsonObject.getInteger("chargeCycleTimes"));
                //剩余电量
                shuttleProtocol.setSurplusQuantity(jsonObject.getInteger("surplusQuantity"));
                //总电量
                shuttleProtocol.setCountQuantity(jsonObject.getInteger("countQuantity"));
                //实际库位xyz
                shuttleProtocol.setPoint(jsonObject.getObject("point", NyShuttleProtocol.NyShuttlePointClass.class));
                //实际坐标xyz
                shuttleProtocol.setCoord(jsonObject.getObject("coord", NyShuttleProtocol.NyShuttlePointClass.class));
                //任务目的库位
                shuttleProtocol.setTask(jsonObject.getObject("task", NyShuttleProtocol.TaskClass.class));
                //任务状态
                shuttleProtocol.setTaskState(jsonObject.getInteger("taskState"));
                //故障状态
                shuttleProtocol.setErrState(jsonObject.getInteger("errState"));
                ArrayList<Integer> errCode = new ArrayList<>();
                for (Object o : jsonObject.getJSONArray("errCode")) {
                    errCode.add(Integer.parseInt(o.toString()));
                }
                //故障码
                shuttleProtocol.setErrCode(errCode);
                //总里程数
                shuttleProtocol.setStatusSum(jsonObject.getObject("statusSum", NyShuttleProtocol.StatusSumClass.class));
                //非自动状态时间计时
                shuttleProtocol.setErrTime(jsonObject.getInteger("errTime"));

                //小车处于运行中，将标记置为true
                if (shuttleProtocol.getFree() == 0) {
                    shuttleProtocol.setPakMk(true);
                }

                //将四向穿梭车状态保存至数据库
                BasShuttleService shuttleService = SpringUtils.getBean(BasShuttleService.class);
                BasShuttle basShuttle = shuttleService.selectById(slave.getId());
                if (basShuttle == null) {
                    basShuttle = new BasShuttle();
                    //四向穿梭车号
                    basShuttle.setShuttleNo(slave.getId());
                    shuttleService.insert(basShuttle);
                }
                //工作模式
                basShuttle.setWorkingMode(shuttleProtocol.getWorkingMode());
                //运行状态
                basShuttle.setFree(shuttleProtocol.getFree());
                //当前速度
                basShuttle.setSpeed(shuttleProtocol.getSpeed());
                //负载状态
                basShuttle.setLoadState(shuttleProtocol.getLoadState());
                //管制状态
                basShuttle.setSuspendState(shuttleProtocol.getSuspendState());
                //顶升位置
                basShuttle.setLiftPosition(shuttleProtocol.getLiftPosition());
                //运行方向
                basShuttle.setRunDir(shuttleProtocol.getRunDir());
                //运行方向
                basShuttle.setRunDir2(shuttleProtocol.getRunDir2());
                //充电状态
                basShuttle.setChargState(shuttleProtocol.getChargState());
                //电池电量
                basShuttle.setPowerPercent(shuttleProtocol.getPowerPercent());
                //最高电芯电压
                basShuttle.setMaxCellVoltage(shuttleProtocol.getMaxCellVoltage());
                //电池电压
                basShuttle.setVoltage(shuttleProtocol.getVoltage());
                //充放电循环次数
                basShuttle.setChargeCycleTimes(shuttleProtocol.getChargeCycleTimes());
                //剩余电量
                basShuttle.setSurplusQuantity(shuttleProtocol.getSurplusQuantity());
                //总电量
                basShuttle.setCountQuantity(shuttleProtocol.getCountQuantity());
                //实际库位
                basShuttle.setPoint(JSONObject.toJSONString(shuttleProtocol.getPoint()));
                //实际坐标
                basShuttle.setCoord(JSONObject.toJSONString(shuttleProtocol.getCoord()));
                //任务目的库位
                basShuttle.setTask(JSONObject.toJSONString(shuttleProtocol.getTask()));
                //任务状态
                basShuttle.setTaskState(shuttleProtocol.getTaskState());
                //故障状态
                basShuttle.setErrState(shuttleProtocol.getErrState());
                //总里程数
                basShuttle.setStatusSum(JSONObject.toJSONString(shuttleProtocol.getStatusSum()));
                //非自动状态时间计时
                basShuttle.setErrTime(shuttleProtocol.getErrTime());
                //任务号
                basShuttle.setWrkNo(shuttleProtocol.getTaskNo().intValue());
                //修改时间
                basShuttle.setUpdateTime(new Date());
                //作业标记
                basShuttle.setPakMk(shuttleProtocol.getPakMk());
                if (shuttleService.updateById(basShuttle)) {
                    OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));
//                    log.info(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
        }
    }

    @Override
    public boolean connect() {
        return true;
    }

    @Override
    public void close() {

    }

    private boolean write(NyShuttleHttpCommand command){
        if (null == command) {
            News.error("四向穿梭车写入命令为空");
            return false;
        }
        BasShuttleService shuttleService = SpringUtils.getBean(BasShuttleService.class);
        if (shuttleService == null) {
            News.error("系统错误");
            return false;
        }

        BasShuttle basShuttle = shuttleService.selectById(slave.getId().shortValue());
        if (basShuttle == null) {
            News.error("四向穿梭车不存在");
            return false;
        }

        //发出请求
        JSONObject result = NyHttpUtils.requestCommand(command);
        if (result == null) {
            return false;//请求失败
        }

        return true;
    }

    //分配任务
    private void assignWork(ShuttleAssignCommand assignCommand) {
        ShuttleRedisCommand redisCommand = new ShuttleRedisCommand();
        redisCommand.setShuttleNo(assignCommand.getShuttleNo());//四向穿梭车号
        redisCommand.setWrkNo(assignCommand.getTaskNo());//工作号
        redisCommand.setCommandStep(0);//命令执行步序
        redisCommand.setAssignCommand(assignCommand);//命令
        shuttleProtocol.setTaskNo(assignCommand.getTaskNo().intValue());
        shuttleProtocol.setAssignCommand(assignCommand);
        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WORKING);
        //任务数据保存到redis
        redisUtil.set("shuttle_wrk_no_" + assignCommand.getTaskNo(), JSON.toJSONString(redisCommand));
        //执行下发任务
        executeWork(assignCommand.getTaskNo());
    }

    //执行下发的指令
    private boolean executeWork(Short wrkNo) {
        //读取redis数据
        if (wrkNo == null) {
            return false;
        }

        WrkMastService wrkMastService = SpringUtils.getBean(WrkMastService.class);

        Object o = redisUtil.get("shuttle_wrk_no_" + wrkNo);
        if (o == null) {
            return false;
        }
        ShuttleRedisCommand redisCommand = JSON.parseObject(o.toString(), ShuttleRedisCommand.class);
        List<NyShuttleHttpCommand> commands = redisCommand.getAssignCommand().getCommands();
        ShuttleAssignCommand assignCommand = redisCommand.getAssignCommand();
        //当前步序
        int commandStep = redisCommand.getCommandStep();
        if (commands.size() == 0) {
            return false;
        }
        //取出命令
        NyShuttleHttpCommand command = commands.get(commandStep);

        if (shuttleProtocol.getFree() == ShuttleStatusType.BUSY.id) {
            return false;//小车状态忙，禁止执行命令
        }

        //检测小车是否要进提升机，如需要进提升机则调度提升机
        if (!checkLiftStation(wrkNo)) {
            return false;
        }

        //检查路径是否可行走(检查路径锁定状态，检测路径是否有其他小车)


        //可执行命令
        if (!write(command)) {
            News.error("四向穿梭车命令下发失败，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
            return false;
        }

        News.info("四向穿梭车命令下发成功，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
        //将标记置为false(防止重发)
        shuttleProtocol.setPakMk(false);

        //保存数据到数据库做流水
        BasShuttleOptService shuttleOptService = SpringUtils.getBean(BasShuttleOptService.class);
        if (shuttleOptService != null) {
            BasShuttleOpt opt = new BasShuttleOpt(
                    assignCommand.getTaskNo().intValue(),
                    assignCommand.getShuttleNo().intValue(),
                    new Date(),
                    ShuttleTaskModeType.get(assignCommand.getTaskMode()).desc,
                    assignCommand.getSourceLocNo(),
                    assignCommand.getLocNo(),
                    null,
                    null,
                    null,
                    JSON.toJSONString(command),
                    null
            );
            shuttleOptService.insert(opt);
        }

        //判断数据是否执行完成
        if (commandStep < commands.size() - 1) {
            //更新redis数据
            //步序增加
            commandStep++;
            redisCommand.setCommandStep(commandStep);
            //任务数据保存到redis
            redisUtil.set("shuttle_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));
        }else {
            //已执行完成

//            if (redisCommand.getLiftSecurityMk()) {
//                //曾锁定过提升机，需要进行解锁
//                if (liftProtocol != null) {
//                    liftProtocol.setSecurityMk(false);
//                }
//            }

//            String locNo = shuttleProtocol.getLocNo() == null ? shuttleProtocol.getSourceLocNo() : shuttleProtocol.getLocNo();
//            if (locNo != null) {
//                //解除锁定的库位路径
//                NavigateMapData navigateMapData = new NavigateMapData(Utils.getLev(locNo));
//                navigateMapData.writeNavigateNodeToRedisMap(redisCommand.getAssignCommand().getNodes(), false);
//            }

            //删除redis
            redisUtil.del("shuttle_wrk_no_" + redisCommand.getWrkNo());

            if (!assignCommand.getCharge()) {
                //对主线程抛出等待确认状态waiting
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WAITING);
            }else {
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
            }
            News.info("四向穿梭车任务执行下发完成等待执行结束，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
        }

        return true;
    }

    //检测小车是否要进提升机，如需要进提升机则调度提升机
    private boolean checkLiftStation(Short wrkNo) {
        //读取redis数据
        if (wrkNo == null) {
            return false;
        }

        Object o = redisUtil.get("shuttle_wrk_no_" + wrkNo);
        if (o == null) {
            return false;
        }

        //拿到提升机线程
        LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
        if (liftThread == null) {
            return false;
        }
        LiftProtocol liftProtocol = liftThread.getLiftProtocol();
        if (liftProtocol == null) {
            return false;
        }

        ShuttleRedisCommand redisCommand = JSON.parseObject(o.toString(), ShuttleRedisCommand.class);
        //当前步序
        int commandStep = redisCommand.getCommandStep();

        //检测是否存在提升机口的指令
        List<NyShuttleHttpCommand> commands = redisCommand.getAssignCommand().getCommands();
        if (commands.size() == 0) {
            return false;
        }

        if (!commands.get(commandStep).getMsgType().equals("move")) {
            return true;//不是行走命令，直接放行
        }


        return false;//默认不放行
    }

}