package com.ruoyi.fuzhou.utils;

import com.ruoyi.fuzhou.domain.ReceiveModuleInfo;
import com.serotonin.modbus4j.*;
import com.serotonin.modbus4j.code.DataType;
import com.serotonin.modbus4j.exception.*;
import com.serotonin.modbus4j.ip.IpParameters;
import com.serotonin.modbus4j.locator.BaseLocator;
import com.serotonin.modbus4j.msg.*;

import java.util.ArrayList;
import java.util.List;

public class Modbus4jUtils {
    static ModbusFactory modbusFactory;

    static {
        modbusFactory = new ModbusFactory();
    }

    public static ModbusMaster getMaster(String ip, Integer port) throws ModbusInitException {
        IpParameters paras = new IpParameters();
        paras.setHost(ip);
        paras.setPort(port);

        ModbusMaster master = modbusFactory.createTcpMaster(paras, false);
        master.init();

        return master;
    }

    /**
     * 读取[01 coil status 0x]类型 开关数据
     */
    public static Boolean readCoilStatus(ModbusMaster master, int slaveId, int offset) throws ModbusTransportException, ErrorResponseException {
        BaseLocator<Boolean> loc = BaseLocator.coilStatus(slaveId, offset);

        return master.getValue(loc);
    }

    /**
     * 读取[02 input status 1x]类型 开关数据
     */
    public static Boolean reaInputStatus(ModbusMaster master, int slaveId, int offset) throws ModbusTransportException, ErrorResponseException {
        BaseLocator<Boolean> loc = BaseLocator.inputStatus(slaveId, offset);

        return master.getValue(loc);
    }

    /**
     * 读取[03 holding register 2x]模拟量数据
     */
    public static Number readHoldingRegister(ModbusMaster master, int slaveId, int offset, int dataType) throws ModbusTransportException, ErrorResponseException {
        BaseLocator<Number> loc = BaseLocator.holdingRegister(slaveId, offset, dataType);

        return master.getValue(loc);
    }

    /**
     * 读取[04 input register 3x]模拟量数据
     */
    public static Number readInputRegister(ModbusMaster master, int slaveId, int offset, int dataType) throws ModbusTransportException, ErrorResponseException {
        BaseLocator<Number> loc = BaseLocator.inputRegister(slaveId, offset, dataType);

        return master.getValue(loc);
    }

    /**
     * 批量读取
     */
    public static List<Integer> batchRead(ModbusMaster master, int count, int slaveId, int dataType) throws ModbusTransportException, ErrorResponseException {
        BatchRead<Integer> batch = new BatchRead<>();

        for (int i = 0; i < count; i++) {
            batch.addLocator(i, BaseLocator.holdingRegister(slaveId, i, dataType));
        }
        batch.setContiguousRequests(false);

        BatchResults<Integer> results = master.send(batch);
        List<Integer> list = new ArrayList();
        for (int i = 0; i < count; i++) {
            list.add(results.getIntValue(i));
        }

        return list;
    }

    /**
     * 写[01 coil status 0x]一个
     */
    public static Boolean writeCoil(ModbusMaster master, int slaveId, int offset, boolean value) throws ModbusTransportException, ErrorResponseException {
        WriteCoilRequest request = new WriteCoilRequest(slaveId, offset, value);
        WriteCoilResponse response = (WriteCoilResponse) master.send(request);

        return !response.isException();
    }

    /**
     * 写[01 coil status 0x]多个
     */
    public static Boolean writeCoils(ModbusMaster master, int slaveId, int startOffset, boolean[] values) throws ModbusTransportException, ErrorResponseException {
        WriteCoilsRequest request = new WriteCoilsRequest(slaveId, startOffset, values);
        WriteCoilsResponse response = (WriteCoilsResponse) master.send(request);

        return !response.isException();
    }

    /**
     * 写[03 holding register 4x]一个
     */
    public static Boolean writeRegister(ModbusMaster master, int slaveId, int offset, short value) throws ModbusTransportException, ErrorResponseException {
        WriteRegisterRequest request = new WriteRegisterRequest(slaveId, offset, value);
        WriteRegisterResponse response = (WriteRegisterResponse) master.send(request);

        return !response.isException();
    }

    /**
     * 写[03 holding register 4x]多个
     */
    public static Boolean writeRegisters(ModbusMaster master, int slaveId, int startOffset, short[] values) throws ModbusTransportException, ErrorResponseException {
        WriteRegistersRequest request = new WriteRegistersRequest(slaveId, startOffset, values);
        WriteRegistersResponse response = (WriteRegistersResponse) master.send(request);

        return !response.isException();
    }

    /**
     * 写入数字类型的模拟量
     */
    public static Boolean writeHoldingRegister(ModbusMaster master, int slaveId, int offset, Number value, int dataType) throws ModbusTransportException, ErrorResponseException {
        BaseLocator<Number> locator = BaseLocator.holdingRegister(slaveId, offset, dataType);
        master.setValue(locator, value);

        return true;
    }

    public static boolean getYdkfmStatus(ReceiveModuleInfo rmi) throws Exception {
        String ip = null == rmi.getIp() ? "localhost" : rmi.getIp();
        ModbusMaster master = getMaster(ip, rmi.getPort());

        Number val = readHoldingRegister(master, 1, 7, DataType.TWO_BYTE_INT_SIGNED);

        return val.intValue() > 1;
    }

    public static boolean ctrlYdkfm(ReceiveModuleInfo rmi, Boolean flag) throws Exception {
        String ip = null == rmi.getIp() ? "localhost" : rmi.getIp();
        ModbusMaster master = getMaster(ip, rmi.getPort());

        short val = (short) (flag ? 2 : 1);
        return writeRegister(master, 1, 7, val);
    }
}