package com.zy.core.thread;

import HslCommunication.Core.Types.OperateResult;
import HslCommunication.Core.Types.OperateResultExOne;
import HslCommunication.Profinet.Siemens.SiemensPLCS;
import HslCommunication.Profinet.Siemens.SiemensS7Net;
import com.alibaba.fastjson.JSON;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.SpringUtils;
import com.core.exception.CoolException;
import com.zy.asrs.entity.BasSte;
import com.zy.asrs.entity.BasSteOpt;
import com.zy.asrs.service.BasSteOptService;
import com.zy.asrs.service.BasSteService;
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.enums.SlaveType;
import com.zy.core.enums.SteLocaType;
import com.zy.core.enums.SteStatusType;
import com.zy.core.model.SteSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.SteCommand;
import com.zy.core.model.protocol.SteProtocol;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

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

/**
 * shuttle 穿梭车线程
 * Created by vincent on 2020/8/4
 * 不能有 槽号 和 机架号
 */
@Data
@Slf4j
public class SteThread implements Runnable, ThreadHandler {

    private SiemensS7Net siemensS7Net;
    private SteSlave slave;
    private SteProtocol steProtocol;
    private short heartBeatVal = 1;
    private boolean resetFlag = false;

    public SteThread(SteSlave slave) {
        this.slave = slave;
    }

    @Override
    @SuppressWarnings("InfiniteLoopStatement")
    public void run() {
        this.connect();
        while (true) {
            try {
                int step = 1;
                Task task = MessageQueue.poll(SlaveType.Ste, slave.getId());
                if (task != null) {
                    step = task.getStep();
                }
                switch (step) {
                    // 读数据
                    case 1:
                        readStatus();
                        break;
                    // 写入数据
                    case 2:
                        write((SteCommand) task.getData());
                        break;
                    default:
                        break;
                }
                // 心跳
//                heartbeat();
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

    /**
     * 初始化堆垛机状态
     */
    private void initSte() {
        if (null == steProtocol) {
            steProtocol = new SteProtocol();
        }
        steProtocol.setSteNo(slave.getId().shortValue());
        steProtocol.setMode((short) 0);
        steProtocol.setStatus(SteStatusType.OFF_LINE);
        steProtocol.setTaskNo((short) 0);
        steProtocol.setExecute(false);
        steProtocol.setWaiting(false);
    }

    @Override
    public boolean connect() {
        boolean result = false;
        //
        siemensS7Net = new SiemensS7Net(SiemensPLCS.S1200, slave.getIp());
        siemensS7Net.setRack(slave.getRack().byteValue());
        siemensS7Net.setSlot(slave.getSlot().byteValue());
        OperateResult connect = siemensS7Net.ConnectServer();
        if(connect.IsSuccess){
            result = true;
            OutputQueue.STE.offer(MessageFormat.format( "【{0}】穿梭车plc连接成功 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            News.info("穿梭车plc连接成功 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
        } else {
            OutputQueue.STE.offer(MessageFormat.format("【{0}】穿梭车plc连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}] ", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            News.error("穿梭车plc连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
            initSte();
        }
//        melsecMcNet.ConnectClose();
        return result;
    }

    /**
     * 读取状态
     */
    private void readStatus(){
        try {
            OperateResultExOne<byte[]> result = siemensS7Net.Read("DB101.0", (short) 28);
            if (result.IsSuccess) {
                if (null == steProtocol) {
                    steProtocol = new SteProtocol();
                    steProtocol.setSteNo(slave.getId().shortValue());
                }
                steProtocol.setMode(siemensS7Net.getByteTransform().TransInt16(result.Content, 2));
                steProtocol.setStatus(siemensS7Net.getByteTransform().TransInt16(result.Content, 4));

                OperateResultExOne<Boolean> waitingRes = siemensS7Net.ReadBool("DB101.20.2");
                if (waitingRes.IsSuccess) {
                    steProtocol.setWaiting(waitingRes.Content);
                }

                steProtocol.setCharge(siemensS7Net.getByteTransform().TransSingle(result.Content, 6));
                steProtocol.setTaskNo(siemensS7Net.getByteTransform().TransInt16(result.Content, 10));
                steProtocol.setTaskType(siemensS7Net.getByteTransform().TransInt16(result.Content, 12));
                steProtocol.setRow(siemensS7Net.getByteTransform().TransInt16(result.Content, 14));
                steProtocol.setBay(siemensS7Net.getByteTransform().TransInt16(result.Content, 16));
                steProtocol.setLev(siemensS7Net.getByteTransform().TransInt16(result.Content, 18));
                steProtocol.setLoca(siemensS7Net.getByteTransform().TransInt16(result.Content, 20));
                steProtocol.setLocaStart(siemensS7Net.getByteTransform().TransInt16(result.Content, 22));
                steProtocol.setLocaEnd(siemensS7Net.getByteTransform().TransInt16(result.Content, 24));
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result.Content, 26, 1);
//                steProtocol.setReady(status[0]?(short)1:(short)0);
//                steProtocol.setReady(status[1]?(short)1:(short)0);
                steProtocol.setReady(status[3]?(short)1:(short)0);
//                steProtocol.setReady(status[3]?(short)1:(short)0);
//                steProtocol.setTrack(status[6]?(short)1:(short)0);

                boolean[] status2 = siemensS7Net.getByteTransform().TransBool(result.Content, 27, 1);

                steProtocol.setChargeStatus(status2[0]?(short)1:(short)0);
                steProtocol.setTrack(status2[1]?(short)1:(short)0);

//                steProtocol.setLoad(status2[6]?(short)1:(short)0);
                steProtocol.setLoad(status2[7]?(short)1:(short)0);

                OutputQueue.STE.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));

//                // 复位信号
//                if (steProtocol.getWaiting()) {
//                    if (resetFlag) {
//                        SteCommand steCommand = new SteCommand();
//                        steCommand.setComplete(true);
//                        if (write(steCommand) && confirmPos()) {
//                            resetFlag = false;
//                        }
//                    }
//                }

                // 根据实时信息更新数据库
                BasSteService service = SpringUtils.getBean(BasSteService.class);
                if (null != service) {
                    // 同步pakMk
                    BasSte one = service.selectById(slave.getId());
                    if (one != null) {
                        steProtocol.setPakMk(one.getPakMk());
                    }

                    BasSte basSte = new BasSte();
                    basSte.setSteNo(slave.getId());
                    if (!service.updateById(steProtocol.toSqlModel(basSte))){
                        News.error("穿梭车plc数据库更新失败 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
                    }

                }
            } else {
                OutputQueue.STE.offer(MessageFormat.format("【{0}】{1}穿梭车plc状态信息失败",DateUtils.convert(new Date()), slave.getId()));
                throw new CoolException(MessageFormat.format( "穿梭车plc状态信息失败 ===>> [id:{0}] [ip:{1}] [port:{2}]", slave.getId(), slave.getIp(), slave.getPort()));
            }
        } catch (Exception e) {
            OutputQueue.STE.offer(MessageFormat.format("【{0}】读取穿梭车plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            initSte();
        }

    }

    /**
     * 写入数据
     */
    private boolean write(SteCommand command){
        return this.write(command, 1);
    }

    /**
     * 写入数据
     */
    private boolean write(SteCommand command, int times){
        if (null == command || times > 2) {
            News.error("穿梭车写入命令为空");
            return false;
        }
        command.setSteNo(slave.getId());
        OperateResult result = null;
        News.error("穿梭车写入命令"+JSON.toJSONString(command));

        // 开始任务
        if (!command.getComplete()) {
            //组织任务前，先清空写任务确认位，以及任务完成确认位
            siemensS7Net.Write("DB100.0", (short) 0);//设备号
            siemensS7Net.Write("DB100.2", (short) 0);//任务号
            siemensS7Net.Write("DB100.12", (short) 0);//起始点位
            siemensS7Net.Write("DB100.14", (short) 0);//目的点位
            siemensS7Net.Write("DB100.16.0", false);//任务开始确认位
            siemensS7Net.Write("DB100.16.1", false);//任务完成确认位
//            siemensS7Net.Write("DB100.18", (short) 0);//硫化罐号
            // 1.任务号
            OperateResult result0 = siemensS7Net.Write("DB100.2", command.getTaskNo().shortValue());
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 作业
            if (command.getTaskMode() != 0) {
                // 2.作业
                OperateResult result1 = siemensS7Net.Write("DB100.4", command.getTaskMode());
                OperateResult result2 = siemensS7Net.Write("DB100.12", (short) command.getStartLoad().shortValue());//起始点位
                OperateResult result3 = siemensS7Net.Write("DB100.14", (short) command.getEndLoad().shortValue());//目的点位
                OperateResult result4 = siemensS7Net.Write("DB100.18", (short) command.getJarNo());//目的点位
                // 3.确认开始任务
                if (result0.IsSuccess && result1.IsSuccess && result2.IsSuccess && result3.IsSuccess && result4.IsSuccess) {
                    result = siemensS7Net.Write("DB100.16.0", true);

                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
            // 任务完成
        } else {
//            siemensS7Net.Write("DB100.2", (short) 0);//任务号
//            siemensS7Net.Write("DB100.4.0", (short) 0);//任务类型
            siemensS7Net.Write("DB100.16.0", false);//任务开始确认位

            result = siemensS7Net.Write("DB100.16.1", true);//任务完成确认
        }

        try {
            // 日志记录
            if (!command.getComplete() && command.getTaskMode() != 0) {
                BasSteOptService bean = SpringUtils.getBean(BasSteOptService.class);
                if (null != bean) {
                    BasSteOpt basSteOpt = new BasSteOpt(
                            command.getTaskNo(),    // 任务号
                            command.getSteNo(),    // 穿梭车
                            new Date(),    // 下发时间
                            command.getTaskModeType().desc,    // 作业
                            null,    // 源排
                            null,    // 源列
                            null,    // 源层
                            null,    // 源站
                            null,    // 目标排
                            null,    // 目标列
                            null,    // 目标层
                            null,    // 目标站
                            null,    // 响应结果
                            null,    // 修改时间
                            null,    // 修改人员
                            null    // 备注
                    );
                    bean.insert(basSteOpt);
                }
            }

        } catch (Exception ignore) {}

        if (result != null && result.IsSuccess) {
            News.info("穿梭车命令下发[id:{}] >>>>> {}", slave.getId(), JSON.toJSON(command));
            OutputQueue.STE.offer(MessageFormat.format("【{0}】[id:{1}] >>>>> 命令下发： {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(command)));
            return true;
        } else {
            OutputQueue.STE.offer(MessageFormat.format("【{0}】写入穿梭车plc数据失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            News.error("写入穿梭车plc数据失败 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
            return false;
        }
    }

    public boolean confirmPos() {
        BasSteService service = SpringUtils.getBean(BasSteService.class);
        BasSte basSte = service.selectById(slave.getId());
        if (basSte != null) {
            // 更新plc数据块
            short[] arr = new short[] {basSte.getRow().shortValue(), basSte.getBay().shortValue(), basSte.getLev().shortValue()};
            OperateResult result = siemensS7Net.Write("DB100.6", arr);
            if (result.IsSuccess) {
                // 更新数据库
                if (service.updatePakMk(this.slave.getId(), "N")) {
                    return true;
                } else {
                    News.error("{}号穿梭车修改数据库定位失败！！！", slave.getId());
                }
            }
        }
        return false;
    }

    public boolean modifyPosHandle(Integer row, Integer bay, Integer lev) {
        short[] arr = new short[] {row.shortValue(), bay.shortValue(), lev.shortValue()};
        OperateResult result = siemensS7Net.Write("DB100.6", arr);
        if (!result.IsSuccess) {
            News.error("更新{}号穿梭车定位失败 ===>> 排：【{}】, 列：【{}】，层：【{}】", this.slave.getId(), row, bay, lev);
            return false;
        }
        BasSteService service = SpringUtils.getBean(BasSteService.class);
        if (!service.updatePos(this.slave.getId(), row, bay, lev)) {
            News.error("更新{}号穿梭车定位失败 ===>> 排：【{}】, 列：【{}】，层：【{}】", this.slave.getId(), row, bay, lev);
            return false;
        }
        return true;
    }

    @Override
    public void close() {
        siemensS7Net.ConnectClose();
    }

    /**
     * 心跳
     */
    private void heartbeat(){
        if (heartBeatVal == 1) {
            heartBeatVal = 2;
        } else {
            heartBeatVal = 1;
        }
        OperateResult write = siemensS7Net.Write("D10", heartBeatVal);
        if (!write.IsSuccess) {
            News.error("输送线plc编号={} 心跳失败", slave.getId());
        }
    }

    /******************************************************************************************/
    /**************************************** 测试专用 *****************************************/
    /*****************************************************************************************/
//    public static void main(String[] args) throws InterruptedException {
//        SteSlave slave = new SteSlave();
//        slave.setId(1);
//        slave.setIp("192.168.2.1");
//        slave.setPort(502);
//        SteThread thread = new SteThread(slave);
//        thread.connect();
//        thread.readStatus();
//        System.out.println(JSON.toJSONString(thread.steProtocol));
//
//        // 穿梭车运行禁止
//        SteCommand command = new SteCommand();
////        command.setRun((short)0);
//        thread.write(command);
//
//    }

}