package com.mes.connect.modbus;

import com.mes.connect.IndustrialInterface.AddressParser;
import com.mes.connect.IndustrialInterface.IndustrialClient;
import com.mes.connect.addressParser.ModbusIpAddressParser;
import com.mes.connect.protocol.ProtocolAddress;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Arrays;
import java.util.logging.Logger;

/**
 * Modbus IP客户端实现（基于UDP）
 */
public class ModbusIpClient implements IndustrialClient {
    private static final Logger logger = Logger.getLogger(ModbusIpClient.class.getName());
    private DatagramSocket socket;
    private final String host;
    private final int port;
    private boolean connected;
    private int transactionId = 0;
    private final AddressParser addressParser = new ModbusIpAddressParser();

    public ModbusIpClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    @Override
    public synchronized void connect() throws IOException {
        if (!connected) {
            socket = new DatagramSocket();
            socket.setSoTimeout(5000); // 5秒超时
            connected = true;
            logger.info("Connected to Modbus IP server: " + host + ":" + port);
        }
    }

    @Override
    public synchronized void disconnect() {
        if (connected) {
            try {
                if (socket != null) {
                    socket.close();
                }
            } finally {
                socket = null;
                connected = false;
                logger.info("Disconnected from Modbus IP server");
            }
        }
    }

    @Override
    public boolean isConnected() {
        return connected && socket != null && !socket.isClosed();
    }


    @Override
    public boolean readBit(String address) throws IOException {
        ProtocolAddress parsedAddress = addressParser.parse(address);
        String[] parts = address.split("\\.");
        String strAddress ="";
        if (parts.length >1) {
            strAddress = parts[0]+"."+parts[1];
        }
        int[] data = readRegisters(strAddress, 1);
        int byteValue = data[0];
        return (byteValue & (1 << parsedAddress.getBit())) != 0;
    }

    @Override
    public void writeBit(String address, boolean value) throws IOException {
        ProtocolAddress parsedAddress = addressParser.parse(address);
        String[] parts = address.split("\\.");
        String strAddress ="";
        if (parts.length >1) {
            strAddress = parts[0]+"."+parts[1];
        }
        int[] currentData = readRegisters(strAddress, 1);
        int byteValue = currentData[0];
        if (value) {
            byteValue |= (1 << parsedAddress.getBit());
        } else {
            byteValue &= ~(1 << parsedAddress.getBit());
        }
        writeRegister(strAddress, byteValue);
    }

//    @Override
//    public boolean readBit(String address) throws IOException {
//        ProtocolAddress parsedAddress = addressParser.parse(address);
//        int functionCode = parsedAddress.getFunctionCode();
//        int startAddress = parsedAddress.getAddress();
//        int bit = parsedAddress.getBit();
//
//        if (functionCode != 1 && functionCode != 2) {
//            throw new IllegalArgumentException("Invalid function code for bit operation: " + functionCode);
//        }
//
//        byte[] request = buildReadRequest(functionCode, startAddress, 1);
//        byte[] response = sendRequest(request);
//
//        if (response[7] == functionCode) {
//            int byteCount = response[8] & 0xFF;
//            if (byteCount >= 1) {
//                byte data = response[9];
//                return (data & (1 << bit)) != 0;
//            }
//        } else if (response[7] == functionCode + 0x80) {
//            int exceptionCode = response[8] & 0xFF;
//            throw new IOException("Modbus exception: " + exceptionCode);
//        }
//
//        throw new IOException("Invalid Modbus response");
//    }
//
//    @Override
//    public void writeBit(String address, boolean value) throws IOException {
//        ProtocolAddress parsedAddress = addressParser.parse(address);
//        int functionCode = parsedAddress.getFunctionCode();
//        int startAddress = parsedAddress.getAddress();
//
//        if (functionCode != 5) {
//            throw new IllegalArgumentException("Invalid function code for write bit operation: " + functionCode);
//        }
//
//        int writeValue = value ? 0xFF00 : 0x0000;
//        byte[] request = buildWriteSingleCoilRequest(startAddress, writeValue);
//        byte[] response = sendRequest(request);
//
//        if (response[7] != functionCode) {
//            if (response[7] == functionCode + 0x80) {
//                int exceptionCode = response[8] & 0xFF;
//                throw new IOException("Modbus exception: " + exceptionCode);
//            }
//            throw new IOException("Invalid Modbus response");
//        }
//    }

    @Override
    public int readRegister(String address) throws IOException {
        ProtocolAddress parsedAddress = addressParser.parse(address);
        int functionCode = parsedAddress.getFunctionCode();
        int startAddress = parsedAddress.getAddress();

        if (functionCode != 3 && functionCode != 4) {
            throw new IllegalArgumentException("Invalid function code for register operation: " + functionCode);
        }

        byte[] request = buildReadRequest(functionCode, startAddress, 1);
        byte[] response = sendRequest(request);

        if (response[7] == functionCode) {
            int byteCount = response[8] & 0xFF;
            if (byteCount >= 2) {
                return ((response[9] & 0xFF) << 8) | (response[10] & 0xFF);
            }
        } else if (response[7] == functionCode + 0x80) {
            int exceptionCode = response[8] & 0xFF;
            throw new IOException("Modbus exception: " + exceptionCode);
        }

        throw new IOException("Invalid Modbus response");
    }

    @Override
    public void writeRegister(String address, int value) throws IOException {
        ProtocolAddress parsedAddress = addressParser.parse(address);
        int functionCode = parsedAddress.getFunctionCode();
        int startAddress = parsedAddress.getAddress();

        if (functionCode != 6) {
            throw new IllegalArgumentException("Invalid function code for write register operation: " + functionCode);
        }

        byte[] request = buildWriteSingleRegisterRequest(startAddress, value);
        byte[] response = sendRequest(request);

        if (response[7] != functionCode) {
            if (response[7] == functionCode + 0x80) {
                int exceptionCode = response[8] & 0xFF;
                throw new IOException("Modbus exception: " + exceptionCode);
            }
            throw new IOException("Invalid Modbus response");
        }
    }

    @Override
    public int[] readRegisters(String address, int quantity) throws IOException {
        ProtocolAddress parsedAddress = addressParser.parse(address);
        int functionCode = parsedAddress.getFunctionCode();
        int startAddress = parsedAddress.getAddress();

        if (functionCode != 3 && functionCode != 4) {
            throw new IllegalArgumentException("Invalid function code for register operation: " + functionCode);
        }

        byte[] request = buildReadRequest(functionCode, startAddress, quantity);
        byte[] response = sendRequest(request);

        if (response[7] == functionCode) {
            int byteCount = response[8] & 0xFF;
            if (byteCount == quantity * 2) {
                int[] result = new int[quantity];
                for (int i = 0; i < quantity; i++) {
                    result[i] = ((response[9 + i*2] & 0xFF) << 8) | (response[10 + i*2] & 0xFF);
                }
                return result;
            }
        } else if (response[7] == functionCode + 0x80) {
            int exceptionCode = response[8] & 0xFF;
            throw new IOException("Modbus exception: " + exceptionCode);
        }

        throw new IOException("Invalid Modbus response");
    }

    @Override
    public void writeRegisters(String address, int[] values) throws IOException {
        ProtocolAddress parsedAddress = addressParser.parse(address);
        int functionCode = parsedAddress.getFunctionCode();
        int startAddress = parsedAddress.getAddress();

        if (functionCode != 16) {
            throw new IllegalArgumentException("Invalid function code for write registers operation: " + functionCode);
        }

        byte[] request = buildWriteMultipleRegistersRequest(startAddress, values);
        byte[] response = sendRequest(request);

        if (response[7] != functionCode) {
            if (response[7] == functionCode + 0x80) {
                int exceptionCode = response[8] & 0xFF;
                throw new IOException("Modbus exception: " + exceptionCode);
            }
            throw new IOException("Invalid Modbus response");
        }
    }

    @Override
    public float readFloat(String address) throws IOException {
        int[] registers = readRegisters(address, 2);
        int intBits = (registers[0] << 16) | registers[1];
        return Float.intBitsToFloat(intBits);
    }

    @Override
    public void writeFloat(String address, float value) throws IOException {
        int intBits = Float.floatToIntBits(value);
        int highWord = (intBits >> 16) & 0xFFFF;
        int lowWord = intBits & 0xFFFF;
        writeRegisters(address, new int[]{highWord, lowWord});
    }

    @Override
    public String readString(String address, int length) throws IOException {
        int[] registers = readRegisters(address, (length + 1) / 2);
        byte[] bytes = new byte[registers.length * 2];

        for (int i = 0; i < registers.length; i++) {
            bytes[i * 2] = (byte) ((registers[i] >> 8) & 0xFF);
            bytes[i * 2 + 1] = (byte) (registers[i] & 0xFF);
        }

        return new String(bytes, 0, length);
    }

    @Override
    public void writeString(String address, String value) throws IOException {
        byte[] bytes = value.getBytes();
        int[] registers = new int[(bytes.length + 1) / 2];

        for (int i = 0; i < bytes.length; i++) {
            int regIndex = i / 2;
            int byteIndex = i % 2;

            if (byteIndex == 0) {
                registers[regIndex] = (bytes[i] & 0xFF) << 8;
            } else {
                registers[regIndex] |= (bytes[i] & 0xFF);
            }
        }

        writeRegisters(address, registers);
    }

    @Override
    public void close() throws IOException {
        disconnect();
    }

    private byte[] buildReadRequest(int functionCode, int startAddress, int quantity) {
        byte[] request = new byte[12];

        // 事务标识符
        request[0] = (byte) (transactionId >> 8);
        request[1] = (byte) transactionId;

        // 协议标识符 (0)
        request[2] = 0;
        request[3] = 0;

        // 长度 (6)
        request[4] = 0;
        request[5] = 6;

        // 单元标识符 (1)
        request[6] = 1;

        // 功能码
        request[7] = (byte) functionCode;

        // 起始地址
        request[8] = (byte) (startAddress >> 8);
        request[9] = (byte) startAddress;

        // 数量
        request[10] = (byte) (quantity >> 8);
        request[11] = (byte) quantity;

        transactionId = (transactionId + 1) % 65536;

        return request;
    }

    private byte[] buildWriteSingleCoilRequest(int address, int value) {
        byte[] request = new byte[12];

        // 事务标识符
        request[0] = (byte) (transactionId >> 8);
        request[1] = (byte) transactionId;

        // 协议标识符 (0)
        request[2] = 0;
        request[3] = 0;

        // 长度 (6)
        request[4] = 0;
        request[5] = 6;

        // 单元标识符 (1)
        request[6] = 1;

        // 功能码 (5)
        request[7] = 5;

        // 地址
        request[8] = (byte) (address >> 8);
        request[9] = (byte) address;

        // 值
        request[10] = (byte) (value >> 8);
        request[11] = (byte) value;

        transactionId = (transactionId + 1) % 65536;

        return request;
    }

    private byte[] buildWriteSingleRegisterRequest(int address, int value) {
        byte[] request = new byte[12];

        // 事务标识符
        request[0] = (byte) (transactionId >> 8);
        request[1] = (byte) transactionId;

        // 协议标识符 (0)
        request[2] = 0;
        request[3] = 0;

        // 长度 (6)
        request[4] = 0;
        request[5] = 6;

        // 单元标识符 (1)
        request[6] = 1;

        // 功能码 (6)
        request[7] = 6;

        // 地址
        request[8] = (byte) (address >> 8);
        request[9] = (byte) address;

        // 值
        request[10] = (byte) (value >> 8);
        request[11] = (byte) value;

        transactionId = (transactionId + 1) % 65536;

        return request;
    }

    private byte[] buildWriteMultipleRegistersRequest(int address, int[] values) {
        int byteCount = values.length * 2;
        byte[] request = new byte[13 + byteCount];

        // 事务标识符
        request[0] = (byte) (transactionId >> 8);
        request[1] = (byte) transactionId;

        // 协议标识符 (0)
        request[2] = 0;
        request[3] = 0;

        // 长度 (7 + byteCount)
        request[4] = 0;
        request[5] = (byte) (7 + byteCount);

        // 单元标识符 (1)
        request[6] = 1;

        // 功能码 (16)
        request[7] = 16;

        // 地址
        request[8] = (byte) (address >> 8);
        request[9] = (byte) address;

        // 寄存器数量
        request[10] = (byte) (values.length >> 8);
        request[11] = (byte) values.length;

        // 字节数
        request[12] = (byte) byteCount;

        // 值
        for (int i = 0; i < values.length; i++) {
            request[13 + i*2] = (byte) (values[i] >> 8);
            request[14 + i*2] = (byte) values[i];
        }

        transactionId = (transactionId + 1) % 65536;

        return request;
    }

    private byte[] sendRequest(byte[] request) throws IOException {
        if (!isConnected()) {
            connect();
        }

        InetAddress address = InetAddress.getByName(host);
        DatagramPacket sendPacket = new DatagramPacket(request, request.length, address, port);

        // 发送请求
        socket.send(sendPacket);

        // 接收响应
        byte[] receiveBuffer = new byte[1024];
        DatagramPacket receivePacket = new DatagramPacket(receiveBuffer, receiveBuffer.length);
        socket.receive(receivePacket);

        return Arrays.copyOf(receiveBuffer, receivePacket.getLength());
    }
}