package com.mes.connect.modbus;

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

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.logging.Logger;

/**
 * Modbus TCP客户端实现
 */
public class ModbusTcpClient implements IndustrialClient {
    private static final Logger logger = Logger.getLogger(ModbusTcpClient.class.getName());
    private Socket socket;
    private DataInputStream inputStream;
    private DataOutputStream outputStream;
    private final String host;
    private final int port;
    private final int unitId;
    private int transactionId = 0;
    private boolean connected;
    private final AddressParser addressParser = new ModbusAddressParser();
    
    public ModbusTcpClient(String host, int port, int unitId) {
        this.host = host;
        this.port = port;
        this.unitId = unitId;
    }
    
    @Override
    public synchronized void connect() throws IOException {
        if (!connected) {
            socket = new Socket(host, port);
            socket.setSoTimeout(5000); // 5秒超时
            inputStream = new DataInputStream(socket.getInputStream());
            outputStream = new DataOutputStream(socket.getOutputStream());
            connected = true;
            logger.info("Connected to Modbus TCP server: " + host + ":" + port);
        }
    }
    
    @Override
    public synchronized void disconnect() {
        if (connected) {
            try {
                if (outputStream != null) outputStream.close();
                if (inputStream != null) inputStream.close();
                if (socket != null) socket.close();
            } catch (IOException e) {
                logger.warning("Error closing Modbus TCP connection: " + e.getMessage());
            } finally {
                outputStream = null;
                inputStream = null;
                socket = null;
                connected = false;
                logger.info("Disconnected from Modbus TCP server");
            }
        }
    }
    
    @Override
    public boolean isConnected() {
        return connected && socket != null && socket.isConnected() && !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();
//        if (functionCode != 1 && functionCode != 2) {
//            throw new IllegalArgumentException("Invalid function code for reading bit: " + functionCode);
//        }
//
//        byte[] request = buildReadRequest(functionCode, parsedAddress.getAddress(), 1);
//        byte[] response = sendRequest(request);
//
//        if (response[8] == 0x01) { // 1字节数据
//            return (response[9] & (1 << parsedAddress.getBit())) != 0;
//        }
//
//        throw new IOException("Unexpected response format for reading bit");
//    }
//
//    @Override
//    public void writeBit(String address, boolean value) throws IOException {
//        ProtocolAddress parsedAddress = addressParser.parse(address);
//        int functionCode = 5; // 写单个线圈
//
//        byte[] request = new byte[12];
//        request[0] = (byte) (transactionId >> 8);    // 事务标识符高字节
//        request[1] = (byte) transactionId++;         // 事务标识符低字节
//        request[2] = 0;                            // 协议标识符高字节 (0)
//        request[3] = 0;                            // 协议标识符低字节 (0)
//        request[4] = 0;                            // 长度高字节
//        request[5] = 6;                            // 长度低字节 (6)
//        request[6] = (byte) unitId;                // 单元标识符
//        request[7] = (byte) functionCode;          // 功能码
//        request[8] = (byte) (parsedAddress.getAddress() >> 8); // 地址高字节
//        request[9] = (byte) parsedAddress.getAddress();        // 地址低字节
//        request[10] = value ? (byte) 0xFF : 0;     // 值 (0xFF00 = ON, 0x0000 = OFF)
//        request[11] = 0;                           // 值低字节
//
//        byte[] response = sendRequest(request);
//
//        // 验证响应
//        if (response[7] != functionCode) {
//            throw new IOException("Modbus exception: " + (response[7] & 0xFF));
//        }
//    }
    
    @Override
    public int readRegister(String address) throws IOException {
        ProtocolAddress parsedAddress = addressParser.parse(address);
        int functionCode = parsedAddress.getFunctionCode();
        if (functionCode != 3 && functionCode != 4) {
            throw new IllegalArgumentException("Invalid function code for reading register: " + functionCode);
        }
        
        byte[] request = buildReadRequest(functionCode, parsedAddress.getAddress(), 1);
        byte[] response = sendRequest(request);
        
        if (response[8] == 0x02) { // 2字节数据
            return ((response[9] & 0xFF) << 8) | (response[10] & 0xFF);
        }
        
        throw new IOException("Unexpected response format for reading register");
    }
    
    @Override
    public void writeRegister(String address, int value) throws IOException {
        ProtocolAddress parsedAddress = addressParser.parse(address);
        int functionCode = 6; // 写单个寄存器
        
        byte[] request = new byte[12];
        request[0] = (byte) (transactionId >> 8);    // 事务标识符高字节
        request[1] = (byte) transactionId++;         // 事务标识符低字节
        request[2] = 0;                            // 协议标识符高字节 (0)
        request[3] = 0;                            // 协议标识符低字节 (0)
        request[4] = 0;                            // 长度高字节
        request[5] = 6;                            // 长度低字节 (6)
        request[6] = (byte) unitId;                // 单元标识符
        request[7] = (byte) functionCode;          // 功能码
        request[8] = (byte) (parsedAddress.getAddress() >> 8); // 地址高字节
        request[9] = (byte) parsedAddress.getAddress();        // 地址低字节
        request[10] = (byte) (value >> 8);         // 值高字节
        request[11] = (byte) value;                // 值低字节
        
        byte[] response = sendRequest(request);
        
        // 验证响应
        if (response[7] != functionCode) {
            throw new IOException("Modbus exception: " + (response[7] & 0xFF));
        }
    }
    
    @Override
    public int[] readRegisters(String address, int quantity) throws IOException {
        ProtocolAddress parsedAddress = addressParser.parse(address);
        int functionCode = parsedAddress.getFunctionCode();
        if (functionCode != 3 && functionCode != 4) {
            throw new IllegalArgumentException("Invalid function code for reading registers: " + functionCode);
        }
        
        byte[] request = buildReadRequest(functionCode, parsedAddress.getAddress(), quantity);
        byte[] response = sendRequest(request);
        
        int byteCount = response[8] & 0xFF;
        int[] result = new int[byteCount / 2];
        
        for (int i = 0; i < result.length; i++) {
            int index = 9 + i * 2;
            result[i] = ((response[index] & 0xFF) << 8) | (response[index + 1] & 0xFF);
        }
        
        return result;
    }
    
    @Override
    public void writeRegisters(String address, int[] values) throws IOException {
        ProtocolAddress parsedAddress = addressParser.parse(address);
        int functionCode = 16; // 写多个寄存器
        
        int byteCount = values.length * 2;
        int requestLength = 9 + byteCount;
        byte[] request = new byte[requestLength];
        
        request[0] = (byte) (transactionId >> 8);    // 事务标识符高字节
        request[1] = (byte) transactionId++;         // 事务标识符低字节
        request[2] = 0;                            // 协议标识符高字节 (0)
        request[3] = 0;                            // 协议标识符低字节 (0)
        request[4] = (byte) ((requestLength - 6) >> 8); // 长度高字节
        request[5] = (byte) (requestLength - 6);         // 长度低字节
        request[6] = (byte) unitId;                // 单元标识符
        request[7] = (byte) functionCode;          // 功能码
        request[8] = (byte) (parsedAddress.getAddress() >> 8); // 地址高字节
        request[9] = (byte) parsedAddress.getAddress();        // 地址低字节
        request[10] = (byte) (values.length >> 8);  // 寄存器数量高字节
        request[11] = (byte) values.length;         // 寄存器数量低字节
        request[12] = (byte) byteCount;             // 字节数
        
        // 填充寄存器值
        for (int i = 0; i < values.length; i++) {
            int index = 13 + i * 2;
            request[index] = (byte) (values[i] >> 8);     // 值高字节
            request[index + 1] = (byte) values[i];        // 值低字节
        }
        
        byte[] response = sendRequest(request);
        
        // 验证响应
        if (response[7] != functionCode) {
            throw new IOException("Modbus exception: " + (response[7] & 0xFF));
        }
    }
    
    @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 address, int quantity) {
        byte[] request = new byte[12];
        request[0] = (byte) (transactionId >> 8);    // 事务标识符高字节
        request[1] = (byte) transactionId++;         // 事务标识符低字节
        request[2] = 0;                            // 协议标识符高字节 (0)
        request[3] = 0;                            // 协议标识符低字节 (0)
        request[4] = 0;                            // 长度高字节
        request[5] = 6;                            // 长度低字节 (6)
        request[6] = (byte) unitId;                // 单元标识符
        request[7] = (byte) functionCode;          // 功能码
        request[8] = (byte) (address >> 8);        // 地址高字节
        request[9] = (byte) address;               // 地址低字节
        request[10] = (byte) (quantity >> 8);      // 数量高字节
        request[11] = (byte) quantity;             // 数量低字节
        
        return request;
    }
    
    private byte[] sendRequest(byte[] request) throws IOException {
        if (!isConnected()) {
            connect();
        }
        
        // 发送请求
        outputStream.write(request);
        outputStream.flush();
        
        // 接收响应
        byte[] header = new byte[6];
        int bytesRead = 0;
        
        // 读取头部
        while (bytesRead < 6) {
            int count = inputStream.read(header, bytesRead, 6 - bytesRead);
            if (count == -1) {
                throw new IOException("Connection closed while reading response header");
            }
            bytesRead += count;
        }
        
        int length = ((header[4] & 0xFF) << 8) | (header[5] & 0xFF);
        byte[] response = new byte[6 + length];
        
        // 复制头部
        System.arraycopy(header, 0, response, 0, 6);
        
        // 读取剩余部分
        bytesRead = 0;
        while (bytesRead < length) {
            int count = inputStream.read(response, 6 + bytesRead, length - bytesRead);
            if (count == -1) {
                throw new IOException("Connection closed while reading response body");
            }
            bytesRead += count;
        }
        // 检查事务标识符
        if ((response[0] & 0xFF) != (request[0] & 0xFF) || (response[1] & 0xFF) != (request[1] & 0xFF)) {
            logger.warning("Transaction ID mismatch in response - expected: " +
                    ((request[0] & 0xFF) << 8 | (request[1] & 0xFF)) +
                    ", got: " + ((response[0] & 0xFF) << 8 | (response[1] & 0xFF)));
            // 虽然事务ID不匹配，但可能是之前请求的响应，选择继续处理而不是抛出异常
        }
        
        // 检查功能码（如果有异常，功能码会是0x80 + 原功能码）
        if ((response[7] & 0xFF) > 0x80) {
            int exceptionCode = response[8] & 0xFF;
            throw new IOException("Modbus exception: " + exceptionCode);
        }
        
        return response;
    }
}