using Common.Attributes;
using DeviceCommand.Base;
using System;
using System.Threading;
using System.Threading.Tasks;

namespace DeviceCommand.Device
{
    [BOBCommand]
    public class PSB11000 : ModbusTcp
    {
        public PSB11000(string IpAddress, int port, int SendTimeout, int ReceiveTimeout)
        {
            ConfigureDevice(IpAddress, port, SendTimeout, ReceiveTimeout);
        }

        public PSB11000() { }

        #region 一、基础控制寄存器

        public virtual async Task 设置远程控制(bool 激活, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(激活 ? 0xFF00 : 0x0000);
            await WriteSingleRegisterAsync(slaveAddress, 402, value, ct);
        }

        public virtual async Task 设置输出(bool 开启, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(开启 ? 0xFF00 : 0x0000);
            await WriteSingleRegisterAsync(slaveAddress, 405, value, ct);
        }

        public virtual async Task 设置工作模式(bool 使用电阻模式, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(使用电阻模式 ? 0xFF00 : 0x0000);
            await WriteSingleRegisterAsync(slaveAddress, 409, value, ct);
        }

        public virtual async Task 重置报警(byte slaveAddress = 1, CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(slaveAddress, 411, 0xFF00, ct);
        }

        public virtual async Task<bool> 查询远程控制(byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] result = await ReadHoldingRegistersAsync(slaveAddress, 402, 1, ct);
            return result[0] == 0xFF00;
        }

        public virtual async Task<bool> 查询输出(byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] result = await ReadHoldingRegistersAsync(slaveAddress, 405, 1, ct);
            return result[0] == 0xFF00;
        }

        public virtual async Task<bool> 查询工作模式(byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] result = await ReadHoldingRegistersAsync(slaveAddress, 409, 1, ct);
            return result[0] == 0xFF00;
        }

        #endregion

        #region 二、电压/电流/功率/电阻设定值

        public virtual async Task 设置电压(double 电压, double 额定电压, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(电压 / 额定电压 * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 500, value, ct);
        }

        public virtual async Task<double> 查询电压(double 额定电压, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 500, 1, ct);
            return reg[0] / (double)0xCCCC * 额定电压;
        }

        public virtual async Task 设置电流(double 电流, double 额定电流, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(电流 / 额定电流 * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 501, value, ct);
        }

        public virtual async Task<double> 查询电流(double 额定电流, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 501, 1, ct);
            return reg[0] / (double)0xCCCC * 额定电流;
        }

        public virtual async Task 设置功率(double 功率, double 额定功率, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(功率 / 额定功率 * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 502, value, ct);
        }

        public virtual async Task<double> 查询功率(double 额定功率, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 502, 1, ct);
            return reg[0] / (double)0xCCCC * 额定功率;
        }

        public virtual async Task 设置电阻(double 电阻, double 最大电阻, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(电阻 / 最大电阻 * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 503, value, ct);
        }

        public virtual async Task<double> 查询电阻(double 最大电阻, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 503, 1, ct);
            return reg[0] / (double)0xCCCC * 最大电阻;
        }

        #endregion

        #region 三、Sink功率设定

        public virtual async Task 设置Sink功率(double 功率, double Sink额定功率, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(功率 / Sink额定功率 * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 498, value, ct);
        }

        public virtual async Task<double> 查询Sink功率(double Sink额定功率, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 498, 1, ct);
            return reg[0] / (double)0xCCCC * Sink额定功率;
        }

        #endregion
    }
}