package com.mes.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Arrays;

public class ATEQ {
    private static final Logger log = LoggerFactory.getLogger(ATEQ.class);

    private SerialUtil serialUtil;
    public String deviceName;

    public ATEQ(SerialUtil serialUtil, String deviceName) {
        this.serialUtil = serialUtil;
        this.deviceName = deviceName;
    }

    public void replaceSerialUtil(SerialUtil serialUtil) {
        this.serialUtil.serialPort.closePort();
        this.serialUtil = serialUtil;
    }

    public boolean stop() {
        byte[] read = serialUtil.read("01 05 00 00 FF 00 8C 3A");
        boolean result = Arrays.equals(read, DataUtils.hexStringToByteArray("01 05 00 00 FF 00 8C 3A"));
        log.info("{}: 气密仪停止{}",deviceName, result ? "成功" : "失败");
        return result;
    }

    public boolean start() {
        byte[] read = serialUtil.read("01 05 00 01 FF 00 DD FA");
        boolean result = Arrays.equals(read, DataUtils.hexStringToByteArray("01 05 00 01 FF 00 DD FA"));
        log.info("{}: 气密仪开始{}",deviceName, result ? "成功" : "失败");
        return result;
    }

    public boolean resetFIFO() {
        byte[] read = serialUtil.read("01 05 00 02 FF 00 2D FA");
        boolean result = Arrays.equals(read, DataUtils.hexStringToByteArray("01 05 00 02 FF 00 2D FA"));
        log.info("{}: 重置FIFO{}", deviceName, result ? "成功" : "失败");
        return result;
    }

    // 读取实时结果
    public RealtimeResult readRealtimeResult() {
        byte[] read = serialUtil.read("01 03 00 30 00 0D 84 00");
        if(read.length > 30) {
            return new RealtimeResult(read);
        } else {
            this.serialUtil.reconnect();
            log.error("{}: 读取<实时结果>时, 返回的数据长度不够, 请检查串口连接", deviceName);
            return null;
        }
    }

    // 读取先入先出队列中的待处理结果
    public FIFOResult readFIFOResult() {
        byte[] read = serialUtil.read("01 03 00 10 00 0D 85 CA");
        if(read.length > 28) {
            return new FIFOResult(read);
        } else {
            log.error("{}: 读取<FIFO结果>时, 返回的数据长度不够, 请检查串口连接", deviceName);
            return null;
        }
    }

    // 读取最后结果
    public LastResult readLastResult() {
        byte[] read = serialUtil.read("01 03 00 11 00 0C 15 CA");
        if(read.length > 20) {
            return new LastResult(read);
        } else {
            log.error("{}: 读取<最后结果>时, 返回的数据长度不够, 请检查串口连接", deviceName);
            return null;
        }
    }



    // 获取参数, 传入程序号, 获取对应程序号的参数
    public Parameters getParams(Integer programNumber) {

        // 步骤1: 选择要编辑的程序
        String s1 = DataUtils.CRC16("01 10 30 04 00 01 02 " + DataUtils.intToWord(programNumber - 1));
        serialUtil.read(s1);

        // 步骤2: 写入要读取的标识符
        String s2 = "01 10 00 00 00 04 08 03 00 01 00 02 00 03 00 F6 F6"; // s2 表示读取3个参数, 分别是 填充时间、稳定时间、测试时间
        serialUtil.read(s2);

        // 步骤3: 读取数据
        byte[] read = serialUtil.read("01 03 00 00 00 09 85 CC");
        if(read.length > 22) {
            return new Parameters(read);
        } else {
            log.error("{}: 读取<参数>时, 返回的数据长度不够, 请检查串口连接", deviceName);
            return null;
        }
    }

    public static class RealtimeResult {
        public final Integer programNumber;
        public final Integer FIFO_Number;
        public final String testType;
        public final String step;
        public final Double pressureValue;
        public final Double leakValue;
        public final Boolean isCycleEnd;
        public final Boolean isPass;
        public final Boolean isKeyExist;
        public final String pressureUnit;
        public final String leakUnit;
        public RealtimeResult(byte[] data) {
            this.programNumber = DataUtils.bytesToInt(Arrays.copyOfRange(data, 3, 5)) + 1;
            this.FIFO_Number = DataUtils.bytesToInt(Arrays.copyOfRange(data, 5, 7));
            this.testType = getTestTypeStr(DataUtils.bytesToInt(Arrays.copyOfRange(data, 7, 9)));
            int state = DataUtils.bytesToInt(Arrays.copyOfRange(data, 9, 11));
            this.isCycleEnd = DataUtils.getBit(state, 5) == 1;
            this.isPass = DataUtils.getBit(state, 0) == 1;
            this.isKeyExist = DataUtils.getBit(state, 15) == 1;
            this.step = getStepStr(DataUtils.bytesToInt(Arrays.copyOfRange(data, 11, 13)));
            this.pressureValue = DataUtils.bytesToInt(Arrays.copyOfRange(data, 13, 17)) / 1000.0;
            this.pressureUnit = getUnit(DataUtils.bytesToInt(Arrays.copyOfRange(data, 17, 21)));
            this.leakValue = DataUtils.bytesToInt(Arrays.copyOfRange(data, 21, 25)) / 1000.0;
            this.leakUnit = getUnit(DataUtils.bytesToInt(Arrays.copyOfRange(data, 25, 29)));
        }

        @Override
        public String toString() {
            return "实时结果{" +
                    " 压力值: " + pressureValue +
                    ", 泄漏值: " + leakValue +
                    ", FIFO数量: " + FIFO_Number +
                    ", 当前步骤: " + step +
                    ", 循环是否结束: " + isCycleEnd +
                    ", 测试通过: " + isPass +
                    ", 是否关键存在: " + isKeyExist +
                    ", 程序号: " + programNumber +
                    ", 测试类型: " + testType +
                    '}';
        }
    }

    public static class FIFOResult {
        public final Integer programNumber;
        public final String testType;
        public final Double pressureValue;
        public final Double leakValue;
        public final Boolean isPass;
        public final Boolean isTestLeak;
        public final Boolean isReferLeak;
        public final String pressureUnit;
        public final String leakUnit;
        public FIFOResult(byte[] data) {
            this.programNumber = DataUtils.bytesToInt(Arrays.copyOfRange(data, 3, 5)) + 1;
            this.testType = getTestTypeStr(DataUtils.bytesToInt(Arrays.copyOfRange(data, 5, 7)));
            int state = DataUtils.bytesToInt(Arrays.copyOfRange(data, 7, 9));
            this.isPass = DataUtils.getBit(state, 0) == 1;
            this.isTestLeak = DataUtils.getBit(state, 1) == 1;
            this.isReferLeak = DataUtils.getBit(state, 2) == 1;
            this.pressureValue = DataUtils.bytesToInt(Arrays.copyOfRange(data, 11, 15)) / 1000.0;
            this.pressureUnit = getUnit(DataUtils.bytesToInt(Arrays.copyOfRange(data, 15, 19)));
            this.leakValue = DataUtils.bytesToInt(Arrays.copyOfRange(data, 19, 23)) / 1000.0;
            this.leakUnit = getUnit(DataUtils.bytesToInt(Arrays.copyOfRange(data, 23, 27)));
        }

        @Override
        public String toString() {
            return "FIFO结果{" +
                    " 压力值: " + pressureValue +
                    ", 泄漏值: " + leakValue +
                    ", 测试通过: " + isPass +
                    ", 测试泄漏: " + isTestLeak +
                    ", 参考泄漏: " + isReferLeak +
                    ", 程序号: " + programNumber +
                    ", 测试类型: " + testType +
                    '}';
        }
    }

    // 最后结果类
    public static class LastResult {
        public final Integer programNumber;         // 程序号
        public final String testType;               // 测试类型
        public final Double pressureValue;          // 压力值
        public final Double leakValue;              // 泄漏值
        public final Boolean isPass;                // 测试是否通过(true表示OK, false表示NG)
        public final Boolean isTestLeak;
        public final Boolean isReferLeak;
        public final String pressureUnit;           // 压力单位
        public final String leakUnit;               // 测试单位
        public LastResult(byte[] data) {
            this.programNumber = DataUtils.bytesToInt(Arrays.copyOfRange(data, 3, 5)) + 1;
            this.testType = getTestTypeStr(DataUtils.bytesToInt(Arrays.copyOfRange(data, 5, 7)));
            int state = DataUtils.bytesToInt(Arrays.copyOfRange(data, 7, 9));
            this.isPass = DataUtils.getBit(state, 0) == 1;
            this.isTestLeak = DataUtils.getBit(state, 1) == 1;
            this.isReferLeak = DataUtils.getBit(state, 2) == 1;
            this.pressureValue = DataUtils.bytesToInt(Arrays.copyOfRange(data, 11, 15)) / 1000.0;
            this.pressureUnit = getUnit(DataUtils.bytesToInt(Arrays.copyOfRange(data, 15, 19)));
            this.leakValue = DataUtils.bytesToInt(Arrays.copyOfRange(data, 19, 23)) / 1000.0;
            this.leakUnit = getUnit(DataUtils.bytesToInt(Arrays.copyOfRange(data, 23, 27)));
        }

        @Override
        public String toString() {
            return "最后结果{" +
                    " 压力值: " + pressureValue +
                    ", 泄漏值: " + leakValue +
                    ", 测试通过: " + isPass +
                    ", 测试泄漏: " + isTestLeak +
                    ", 参考泄漏: " + isReferLeak +
                    ", 程序号: " + programNumber +
                    ", 测试类型: " + testType +
                    ", 压力单位: " + pressureUnit +
                    ", 泄漏单位: " + leakUnit +
                    '}';
        }
    }

    public static class Parameters {
        public final Integer fillTime;         // 填充时间
        public final Integer stabilizeTime;    // 稳定时间
        public final Integer testTime;         // 测试时间

        public Parameters(byte[] data) {
            this.fillTime = DataUtils.bytesToInt(Arrays.copyOfRange(data, 5, 9)) / 1000;
            this.stabilizeTime = DataUtils.bytesToInt(Arrays.copyOfRange(data, 11, 15)) / 1000;
            this.testTime = DataUtils.bytesToInt(Arrays.copyOfRange(data, 17, 21)) / 1000;
        }

        @Override
        public String toString() {
            return "参数{" +
                    "填充时间: " + fillTime +
                    "s, 稳定时间: " + stabilizeTime +
                    "s, 测试时间: " + testTime +
                    "s}";
        }
    }

    private static String getTestTypeStr(Integer testTypeCode) {
        String s = "未知";
        if(testTypeCode == 1) {
            s = "泄漏";
        }
        return s;
    }

    private static String getStepStr(Integer stepCode) {
        String s = "未知";
        switch (stepCode) {
            case 0:
                s = "预填充";
                break;
            case 1:
                s = "预倒置";
                break;
            case 4:
                s = "填充";
                break;
            case 5:
                s = "稳定化";
                break;
            case 6:
                s = "测试";
                break;
            case 7:
                s = "输出";
                break;
            case 65535:
                s = "无步骤";
                break;
        }
        return s;
    }

    private static String getUnit(Integer unitCode) {
        String s = "";
        switch (unitCode) {
            case 0:
                s = "cm3/s";
                break;
            case 1000:
                s = "cm3/min";
                break;
            case 2000:
                s = "cm3/h";
                break;
            case 6000:
                s = "Pa";
                break;
            case 8000:
                s = "Pa/s";
                break;
            case 11000:
                s = "Bar";
                break;
            case 12000:
                s = "kPa";
                break;
            case 50000:
                s = "ml/s";
                break;
            case 51000:
                s = "ml/min";
                break;
            case 52000:
                s = "ml/h";
                break;
        }
        return s;
    }

}