package com.hdl.sdk.ttl.Utils.HDLUtlis;

import android.os.SystemClock;
import android.util.Log;

import com.hdl.sdk.ttl.Config.Global;
import com.hdl.sdk.ttl.HDLDeviceManger.Bean.ReceiveData;
import com.hdl.sdk.ttl.HDLDeviceManger.Bean.SendDatas;
import com.hdl.sdk.ttl.HDLDeviceManger.Bean.UdpDataBean;
import com.hdl.sdk.ttl.HDLDeviceManger.Core.Crc;
import com.hdl.sdk.ttl.HDLDeviceManger.Core.HDLSerialPortCore;

import java.net.InetAddress;
import java.nio.ByteBuffer;
import java.util.Calendar;

/**
 * Created by hxb on 2023/10/18.
 */
public class SerialPortSendAndReceiveUtil {
    private static volatile SerialPortSendAndReceiveUtil instance = null;

    /**
     * 发送线程
     */
    private Thread sendThread;

    /**
     * 接收线程
     */
    private Thread receiveThread;


    private SerialPortSendAndReceiveUtil() {
        sendThread = new Thread(new SendRunnable());
        receiveThread = new Thread(new ReceiveRunnable());
    }

    public static SerialPortSendAndReceiveUtil getInstance() {
        if (instance == null) {
            synchronized (SerialPortSendAndReceiveUtil.class) {
                if (instance == null) {
                    instance = new SerialPortSendAndReceiveUtil();
                }
            }
        }
        return instance;
    }

    public void start() {
        sendThread.start();
        receiveThread.start();

        Global.mReceiveData = data;
    }

    /**
     * 获取封装数据
     *
     * @param body        发送数据内容
     * @param writeOrRead 读写标识，1表示写，2表示读取
     * @return
     */
    private static byte[] getSendByte(byte[] body, int writeOrRead) {
        byte[] crcBytes = new byte[2 + 1 + 1 + body.length + 2];
        crcBytes[0] = (byte) 0XFE;
        crcBytes[1] = (byte) 0xFE;
        crcBytes[2] = (byte) writeOrRead;
        crcBytes[3] = (byte) body.length;
        System.arraycopy(body, 0, crcBytes, 4, body.length);

        //Check CRC
        Crc.CRC16_MODBUS(crcBytes, crcBytes.length);

        return crcBytes;
    }


    static class SendRunnable implements Runnable {
        /**
         * 发送一条后休眠时间
         */
        private int sleepTime = 30;
        /**
         * 重发间隔时间
         */
        private int intervalTime = 500;

        /**
         * 重发次数
         */
        private int reSendCount = 3;

        /**
         * 线程运行状态
         */
        private boolean run = true;

        @Override
        public void run() {
            while (run) {
                try {
                    SystemClock.sleep(sleepTime);
                    if (HDLSerialPortCore.mSerialPort == null) {
                        Log.i("串口-发送->", "串口没有初始化");
                        continue;
                    }

                    for (int i = 0; i < SendDatas.sendDataArrayList.size(); i++) {
                        SendDatas sendDatas = SendDatas.sendDataArrayList.get(i);

                        //第一次发送，时间先初始化
                        if (sendDatas.StartCalendar == null) {
                            sendDatas.StartCalendar = Calendar.getInstance();
                        } else {
                            //距离上次发送的时间如还在重发时间内，先不发
                            if (Calendar.getInstance().getTimeInMillis() - sendDatas.StartCalendar.getTimeInMillis() < intervalTime) {
                                continue;
                            }
                        }
                        //超出特重发数次就不发送，并移除出列表
                        if (sendDatas.SendCount >= reSendCount) {
                            synchronized (SendDatas.sendDataArrayList) {
                                SendDatas.sendDataArrayList.remove(i--);
                            }
                            continue;
                        }

                        sendDatas.StartCalendar = Calendar.getInstance();//重置发送时间
                        sendDatas.SendCount++;

                        byte[] sendBytes = SerialPortSendAndReceiveUtil.getSendByte(sendDatas.GetSerialPortSendBytes(), 1);

                        HDLSerialPortCore.mSerialPort.getOutputStream().write(sendBytes);
                        HDLSerialPortCore.mSerialPort.getOutputStream().flush();
                        SystemClock.sleep(sleepTime);
                    }

                    //发送完成后通知读取缓存数据
                    read();

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }


        }

        /**
         * 通知读取总线缓存数据
         */
        void read() {
            try {
                byte[] body = new byte[]{(byte) 0xFE, (byte) 0xFE, 0x02, 0x01, 0x00, (byte) 0x9C, 0x6C};
                // 发送Data
                HDLSerialPortCore.mSerialPort.getOutputStream().write(body);
                HDLSerialPortCore.mSerialPort.getOutputStream().flush();
                Log.d("串口-发送->", "发送读取");
            } catch (Exception ignored) {
            }
        }
    }

    private static ReceiveData data = new ReceiveData() {

        @Override
        public void receiveData(int command, int desSubnetID, int desDeviceID, int subnetID, int deviceID, byte[] usefulBytes) {
            // 更新发送是否成功的信息
            SendDatas.ReceiveBytes(command, subnetID, deviceID, usefulBytes);
            //2019-8-20 增加目标子网号设备号判断
            if ((desSubnetID == 0xFF && desSubnetID == 0xFF)
                    || (desSubnetID == Crc.localSubnetID && desSubnetID == Crc.localDeviceID)) {
                //参数
                UdpDataBean udpDataBean = new UdpDataBean();
                udpDataBean.sourceSubnetID = subnetID;
                udpDataBean.sourceDeviceID = deviceID;
                udpDataBean.desSubnetID = desSubnetID;
                udpDataBean.desDeviceID = desDeviceID;
                udpDataBean.command = command;

                udpDataBean.addBytes = usefulBytes;
                HDLSerialPortCore.HandleInsideData(udpDataBean);

            }

        }
    };

    static class ReceiveRunnable implements Runnable {
        /**
         * 线程运行状态
         */
        private boolean run = true;

        private byte[] head = new byte[]{(byte) 0xFE, (byte) 0xFE};

        /**
         * 缓存区
         */
        private final ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

        @Override
        public void run() {
            while (run) {
                try {
                    if (HDLSerialPortCore.mSerialPort == null) {
                        Log.i("串口-读取->", "串口没有初始化");
                        continue;
                    }
                    byte[] data = new byte[1024];
                    int size = HDLSerialPortCore.mSerialPort.getInputStream().read(data);
                    if (size <= 0) {
                        continue;
                    }

                    try {
                        byteBuffer.put(data, 0, size);
                        Log.d("串口->回复", byteToHex(data, 0, size) + " position:" + byteBuffer.position());
                    } catch (Exception e) {
                        byteBuffer.flip();
                        byteBuffer.clear();
                    }

                    while (true) {
                        removeInVoidBytes();

                        //没有新的数据，返回
                        if (!haveData()) {
                            break;
                        }


                        int bodyIndex = 2 + 1 + 1;
                        int lenght = byteBuffer.get(3) & 0xFF;

                        byte[] packet = getBody(0, bodyIndex + lenght + 2);
                        //是否已经获取完整所有的数据
                        byte[] tempBytes = getBody(bodyIndex, lenght);
                        remove(bodyIndex + lenght + 2);

                        if (!Crc.CRC16_MODBUS_MATCH(packet, packet.length)) {
                            Log.d("串口->回复", "CRC不对");
                            continue;
                        }
                        if (tempBytes == null) {
                            Log.d("串口->回复", "当前数据还没有接收完成");
                            //当前数据还没有接收完成
                            continue;
                        }

                        if (lenght <= 1) {
                            //设备回复的协议数据
                            continue;
                        }

                        int command = (tempBytes[7] & 0xFF) * 256 + (tempBytes[8] & 0xFF);

                        int subnetID = tempBytes[3] & 0xFF;
                        int deviceID = tempBytes[4] & 0xFF;
                        int desSubnetID = tempBytes[9] & 0xFF;
                        int desDeviceID = tempBytes[10] & 0xFF;
                        //如果不是发给自己的数据或者不是广播的数据，不处理
                        if (desSubnetID != Global.subnetID || desDeviceID != Global.deviceID) {
                            if (desSubnetID != 0xFF || desDeviceID != 0xFF) {
                                Log.d("串口->回复", "过滤掉=={目标子网:" + desSubnetID + ",目标设备:" + desDeviceID + "}");
                                continue;
                            }
                        }

                        byte[] usefulBytes = new byte[(tempBytes[2] & 0xFF) - 11];
                        // 复制附加数据
                        System.arraycopy(tempBytes, 11, usefulBytes, 0, usefulBytes.length);
                        if (Global.mReceiveData != null) {
                            Global.mReceiveData.receiveData(command, desSubnetID, desDeviceID, subnetID, deviceID, usefulBytes);
                        }
                    }

                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }

        private String byteToHex(byte[] bytes, int index, int length) {
            StringBuilder sb = new StringBuilder();
            for (int i = index; i < length; i++) {
                sb.append(String.format(" %02X", bytes[i]));
            }
            return sb.toString();
        }

        /**
         * 获取头部数据
         *
         * @return
         */
        boolean haveData() {

            int length = 2 + 1 + 1 + (byteBuffer.get(3) & 0xFF) + 2;

            //数据还没有接收全
            if (byteBuffer.position() < length) {
                return false;
            }

            return true;
        }

        /**
         * 获取数据内容
         *
         * @param lenght
         * @return
         */
        byte[] getBody(int index, int lenght) {
            //是否已经获取完整所有的数据
            byte[] bodyBytes = new byte[lenght];
            if (index < 0 || byteBuffer.position() < index + lenght) {
                //当前数据还没有接收完成
                return null;
            }

            for (int i = 0; i < bodyBytes.length; i++) {
                bodyBytes[i] = byteBuffer.get(index + i);
            }
            return bodyBytes;
        }

        /**
         * 移除可能存在的无效数据
         */
        void removeInVoidBytes() {
            for (int i = 0; i < dddd.length; i++) {
                dddd[i] = byteBuffer.get(i);
            }
//            Log.d("串口->回复", "position:"+byteBuffer.position()+" 处理前的数据"+byteToHex(dddd, 0, 100));
            int index = 0;
            boolean isMatch = false;
            for (; index < byteBuffer.position() - head.length; index++) {
                isMatch = true;
                for (int j = 0; j < head.length; j++) {
                    if (head[j] != byteBuffer.get(index + j)) {
                        isMatch = false;
                        break;
                    }
                }
                if (isMatch) {
                    break;
                }
            }
            int endIndex = 0;
            if (0 < index && isMatch) {
                endIndex = byteBuffer.position();
                byteBuffer.clear();
                for (int i = index; i < endIndex; i++) {
                    byteBuffer.put(byteBuffer.get(i));
                }
            }

            for (int i = 0; i < dddd.length; i++) {
                dddd[i] = byteBuffer.get(i);
            }
        }

        byte[] dddd = new byte[100];

        /**
         * 移除到指定位置前面的数据
         *
         * @param position 指定位置
         */
        void remove(int position) {
            int endIndex = byteBuffer.position();
            byteBuffer.clear();
            //TODO 清空之前的数据
            for (int i = position; i < endIndex; i++) {
                byteBuffer.put(byteBuffer.get(i));
            }

            for (int i = 0; i < dddd.length; i++) {
                dddd[i] = byteBuffer.get(i);
            }

//            Log.d("串口->回复", "position:"+byteBuffer.position()+" 移除后的数据"+byteToHex(dddd, 0, 100));
        }
    }

}