package com.hdl.photovoltaic.internet;

import android.text.TextUtils;

import com.hdl.sdk.link.core.callback.HDLLinkCallBack;
import com.hdl.sdk.link.core.callback.ModbusCallBack;
import com.hdl.sdk.link.core.connect.HDLModBusConnect;
import com.hdl.sdk.link.gateway.HDLLinkLocalGateway;

import java.nio.ByteBuffer;


/**
 * 客户端操作逻辑
 */
public class TcpClient {

    private static volatile TcpClient sTcpClient;

    /**
     * 获取当前对象
     *
     * @return HdlAccountLogic
     */
    public static synchronized TcpClient getInstance() {
        if (sTcpClient == null) {
            synchronized (TcpClient.class) {
                if (sTcpClient == null) {
                    sTcpClient = new TcpClient();
                }
            }

        }
        return sTcpClient;
    }

    /**
     * 发送数据到Link网关
     *
     * @param mac       网关mac
     * @param isEncrypt 是否加密
     * @param topic     请求主题
     * @param jObject   负载数据<没有填null></>
     * @param sendPath  发送路径<类名+方法名>class->methodName</>
     */
    public void sendDataToLinkGateway(String mac, boolean isEncrypt, String topic, Object jObject, String sendPath, HDLLinkCallBack callBack) {
        HDLLinkLocalGateway.getInstance().sendDataToLinkGateway(mac, isEncrypt, topic, jObject, sendPath, callBack);

    }

    /**
     * 发送数据到Link网关
     *
     * @param mac      网关mac
     * @param topic    请求主题
     * @param jObject  负载数据<没有填null></>
     * @param sendPath 发送路径<类名+方法名>class->methodName</>
     */
    public void sendDataToLinkGateway(String mac, String topic, Object jObject, String sendPath, HDLLinkCallBack callBack) {
        HDLLinkLocalGateway.getInstance().sendDataToLinkGateway(mac, topic, jObject, sendPath, callBack);

    }

    /**
     * 发送ModBus数据到网关
     * 下发主题底层默认
     *
     * @param mac             网关mac
     * @param oidAddresses    oid物理信息里面Addresses地址
     * @param functionCode    功能码【3=（读取多个寄存器),6=（写入单个寄存器）,16=（写入多个寄存器）】
     * @param registerAddress 寄存器地址(根据文档上填十进制值)
     * @param contentData     内容数据（不含寄存器地址）【注意：功能码=3时,根据文档上填数据字节数，例如读取设备备注，填20Byte】
     */
    public void sendModBusDataToLinkGateway(String mac, String oidAddresses, FunctionCode functionCode, int registerAddress, String contentData, ModbusCallBack modbusCallBack) {
        String data = "";
        switch (functionCode) {
            case ReadMultipleRegisters: {
                data = readModbusPassData(oidAddresses, registerAddress, functionCode, contentData);
            }
            break;
            case WriteSingleRegister: {
                data = writeSingleModbusPassData(oidAddresses, registerAddress, functionCode, contentData);
            }
            break;
            case WriteMultipleRegisters: {
                data = writeMultipleModbusPassData(oidAddresses, registerAddress, functionCode, contentData);
            }
            break;
        }
        HDLModBusConnect.getInstance().asyncSend(mac, getDataByteArray(data), modbusCallBack);
    }

    /**
     * 获取读取【modbus协议】拼接透传数据的字符串
     * 下发主题：/user/${gw_id}/custom/native/${driver}/down;
     * 逆变器回复主题：/user/${gw_id}/custom/native/${driver}/down_reply;
     * Modbus ECU协议：事件ID(2个byte)->协议[固定:0,0](2个byte)->长度(2byte)->标识符[oid的addresses值](4个byte)->功能码(1个byte)->负载数据(N个byte);
     * 长度(2个byte)=标识符(4个byte)+功能码(1个byte)+负载数据(N个byte);
     * 负载数据=寄存器地址(2个byte)+寄存器长度(2个byte)+内容长度(1个byte)+内容数据(数据字节数->N个byte)【注意:单个写入寄存器-->去掉<寄存器长度>和<内容长度>】;
     * 寄存器长度=(内容数据/2);
     * 内容长度=内容数据的长度;
     * 例子:new byte[]{1,54,0,0,0,9,0,0,200,26,3,1,54,0,1};
     *
     * @param oidAddresses    oid物理信息里面Addresses地址
     * @param functionCode    功能码【3=（读取多个寄存器)）,6=（写入单个寄存器）,16=（写入多个寄存器）】
     * @param registerAddress 寄存器地址(根据文档上十进制值填)
     * @param contentData     内容数据（不含寄存器地址）
     */
    private String readModbusPassData(String oidAddresses, int registerAddress, FunctionCode functionCode, String contentData) {
        String data = "";
        try {
            String eventID = to2ByteHexString(registerAddress);//事件ID(2byte)
            String agreement = "0000";//协议（2byte）
            String dataByteLength = "";//长度（N byte）
            String oidAddresses_1 = oidAddresses;//标识符（4byte）
            String functionCode_1 = to1ByteHexString(functionCode.value());//功能码（1byte）
            String registerAddress_1 = to2ByteHexString(registerAddress);//寄存器地址（2byte）
            String registerLength_1 = to2ByteHexString(Integer.parseInt(contentData) / 2);//寄存器长度（2byte）
            byte[] bytes = (oidAddresses_1 + functionCode_1 + registerAddress_1 + registerLength_1).getBytes();
            dataByteLength = to2ByteHexString(bytes.length / 2);
            data = eventID + agreement + dataByteLength + oidAddresses_1 + functionCode_1 + registerAddress_1 + registerLength_1;
            return data;
        } catch (Exception ignored) {
            return data;
        }
    }


    /**
     * 获取写入单个【modbus协议】拼接透传数据的字符串
     * 下发主题：/user/${gw_id}/custom/native/${driver}/down;
     * 逆变器回复主题：/user/${gw_id}/custom/native/${driver}/down_reply;
     * Modbus ECU协议：事件ID(2个byte)->协议[固定:0,0](2个byte)->长度(2byte)->标识符[oid的addresses值](4个byte)->功能码(1个byte)->负载数据(N个byte);
     * 长度(2个byte)=标识符(4个byte)+功能码(1个byte)+负载数据(N个byte);
     * 负载数据=寄存器地址(2个byte)+寄存器长度(2个byte)+内容长度(1个byte)+内容数据(数据字节数->N个byte)【注意:单个写入寄存器-->去掉<寄存器长度>和<内容长度>】;
     * 寄存器长度=(内容数据/2);
     * 内容长度=内容数据的长度;
     * 例子:new byte[]{199, 112, 0, 0, 0, 9, 0, 0, 0, 26, 6, 199, 112, 0, 110};
     *
     * @param oidAddresses    oid物理信息里面Addresses地址
     * @param functionCode    功能码【3=（读取多个寄存器)）,6=（写入单个寄存器）,16=（写入多个寄存器）】
     * @param registerAddress 寄存器地址(根据文档上十进制值填)
     * @param contentData     内容数据（不含寄存器地址）
     */
    private String writeSingleModbusPassData(String oidAddresses, int registerAddress, FunctionCode functionCode, String contentData) {
        String data = "";
        try {
            String eventID = to2ByteHexString(registerAddress);//事件ID(2byte)
            String agreement = "0000";//协议（2byte）
            String dataByteLength = "";//长度（N byte）
            String oidAddresses_1 = oidAddresses;//标识符（4byte）
            String functionCode_1 = to1ByteHexString(functionCode.value());//功能码（1byte）
            String registerAddress_1 = to2ByteHexString(registerAddress);//寄存器地址（2byte）
            String contentData_1 = contentData;//内容数据（N byte）
            byte[] bytes = (oidAddresses_1 + functionCode_1 + registerAddress_1 + contentData_1).getBytes();
            dataByteLength = to2ByteHexString(bytes.length / 2);
            data = eventID + agreement + dataByteLength + oidAddresses_1 + functionCode_1 + registerAddress_1 + contentData_1;
            return data;
        } catch (Exception ignored) {
            return data;
        }
    }

    /**
     * 获取写入多个【modbus协议】拼接透传数据的字符串
     * 下发主题：/user/${gw_id}/custom/native/${driver}/down;
     * 逆变器回复主题：/user/${gw_id}/custom/native/${driver}/down_reply;
     * Modbus ECU协议：事件ID(2个byte)->协议[固定:0,0](2个byte)->长度(2byte)->标识符[oid的addresses值](4个byte)->功能码(1个byte)->负载数据(N个byte);
     * 长度(2个byte)=标识符(4个byte)+功能码(1个byte)+负载数据(N个byte);
     * 负载数据=寄存器地址(2个byte)+寄存器长度(2个byte)+内容长度(1个byte)+内容数据(数据字节数->N个byte)【注意:单个写入寄存器-->去掉<寄存器长度>和<内容长度>】;
     * 寄存器长度=(内容数据/2);
     * 内容长度=内容数据的长度;
     * 例子:new byte[]{[0, 11, 0, 0, 0, 30, 0, 0, 0, 26, 16, 0, 11, 0, 10, 20, 49, 50, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32]};
     *
     * @param oidAddresses    oid里面Addresses的值
     * @param functionCode    功能码【3=（读取多个寄存器)）,6=（写入单个寄存器）,16=（写入多个寄存器）】
     * @param registerAddress 寄存器地址(根据文档上十进制值填)
     * @param contentData     内容数据（不含寄存器地址）
     */
    private String writeMultipleModbusPassData(String oidAddresses, int registerAddress, FunctionCode functionCode, String contentData) {

        String data = "";
        try {
            String eventID = to2ByteHexString(registerAddress);//事件ID(2byte)
            String agreement = "0000";//协议（2byte）
            String dataByteLength = "";//长度（N byte）
            String oidAddresses_1 = oidAddresses;//标识符（4byte）
            String functionCode_1 = to1ByteHexString(functionCode.value());//功能码（1byte）
            String registerAddress_1 = to2ByteHexString(registerAddress);//寄存器地址（2byte）
            String registerLength_1 = to2ByteHexString(contentData.length() / 2);//寄存器长度（2byte）
            String contentLength_1 = to1ByteHexString(contentData.length());//内容长度（1byte）
            String contentData_1 = contentData;//内容数据（N byte）
            byte[] bytes = (oidAddresses_1 + functionCode_1 + registerAddress_1 + registerLength_1 + contentLength_1 + contentData_1).getBytes();
            dataByteLength = to2ByteHexString(bytes.length / 2);
            data = eventID + agreement + dataByteLength + oidAddresses_1 + functionCode_1 + registerAddress_1 + registerLength_1 + contentLength_1 + contentData_1;
            return data;
        } catch (Exception ignored) {
            return data;
        }
    }

    /**
     * 逐个解析两个字符，将其转换为字节
     *
     * @param hexString 16进制的字符串
     * @return 返回数组
     */
    private byte[] getDataByteArray(String hexString) {
        try {
            if (TextUtils.isEmpty(hexString)) {
                return new byte[]{};
            }
            //去除字符串前后的空格
            hexString = hexString.trim();
            // 确保字符串的长度是偶数
            if (hexString.length() % 2 != 0) {
                //无效的十六进制字符串
                return new byte[]{};
            }
            // 计算字节数组的长度
            int byteArrayLength = hexString.length() / 2;
            byte[] byteArray = new byte[byteArrayLength];
            //逐个解析两个字符，将其转换为字节
            for (int i = 0; i < byteArrayLength; i++) {
                byteArray[i] = (byte) Integer.parseInt(hexString.substring(i * 2, i * 2 + 2), 16);
            }
            return byteArray;
        } catch (Exception ignored) {
            return new byte[]{};
        }
    }

    /**
     * 获取十六进制字符串(不够两位前面补0)
     *
     * @param value 寄存器地址(十进制)
     * @return (2byte)十六进制字符串
     */
    private String to2ByteHexString(int value) {
        String high = "";
        String low = "";
        if (value > 255) {
            high = to1ByteHexString(value / 256);

            low = to1ByteHexString(value % 256);
        } else {
            high = "00";
            low = to1ByteHexString(value);
        }
        return high + low;
    }

    /**
     * 获取十六进制字符串(不够两位前面补0)
     *
     * @param value 十进制
     * @return (1byte)十六进制字符串
     */
    private String to1ByteHexString(int value) {
        try {
            String hexString = Integer.toHexString(value);
            if (hexString.length() == 1) {
                return "0" + hexString;
            }
            return hexString;
        } catch (Exception e) {
            return "00";
        }
    }


    /**
     * 获取十六进制字符串(不够两位前面补0)
     *
     * @param dataBytes 数组
     * @return -(n byte)十六进制字符串
     */
    private String toNByteHexString(byte[] dataBytes) {
        StringBuilder stringBuilder = new StringBuilder();
        for (byte dataByte : dataBytes) {
            String dataB = Integer.toHexString(dataByte & 0xFF);
            if (dataB.length() == 1) {
                dataB = "0" + dataB;
            }
            stringBuilder.append(dataB);
        }
        return stringBuilder.toString();
    }

    /**
     * 获取十六进制字符串(不够两位前面补0)
     *
     * @param value 寄存器地址(十进制)
     * @return (2byte)十六进制字符串
     */
    private String getByteHexString(int value) {
        String high = "";
        String low = "";
        if (value > 255) {
            high = to1ByteHexString(value / 256);

            low = to1ByteHexString(value % 256);
        } else {
            high = "00";
            low = to1ByteHexString(value);
        }
        return high + low;
    }

    /**
     * bytes数组转Int值
     *
     * @param bytes 数据
     */
    public int toByteArrayInt(byte[] bytes) {
        int ans = 0;
        for (byte b : bytes) {
            ans <<= 8;
            ans |= (b & 0xff);
        }
        return ans;
    }


    /**
     * 功能码
     */
    public enum FunctionCode {

        /**
         * 读取单个或者多个寄存器
         */
        ReadMultipleRegisters(3),
        /**
         * 写入单个寄存器
         */
        WriteSingleRegister(6),
        /**
         * 写入多个寄存器
         */
        WriteMultipleRegisters(16);
        private int mValue;

        FunctionCode(int value) {
            this.mValue = value;
        }

        public int value() {
            return this.mValue;
        }
    }
}