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

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

        public EAEL9080() { }

        #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<uint> 查询设备状态(byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 505, 2, ct);
            return (uint)(reg[0] << 16 | reg[1]);
        }

        public virtual async Task<bool> 查询直流开启状态(byte slaveAddress = 1, CancellationToken ct = default)
        {
            uint status = await 查询设备状态(slaveAddress, ct);
            return (status & (1 << 7)) != 0;
        }

        public virtual async Task<bool> 查询远程控制状态(byte slaveAddress = 1, CancellationToken ct = default)
        {
            uint status = await 查询设备状态(slaveAddress, ct);
            return (status & (1 << 10)) != 0;
        }

        public virtual async Task<bool> 查询Sink模式状态(byte slaveAddress = 1, CancellationToken ct = default)
        {
            uint status = await 查询设备状态(slaveAddress, ct);
            return (status & (1 << 12)) != 0;
        }

        #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 设置Sink电流(double 电流, double Sink额定电流, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(电流 / Sink额定电流 * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 499, value, ct);
        }

        public virtual async Task 设置Sink电阻(double 电阻, double Sink最大电阻, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort value = (ushort)(电阻 / Sink最大电阻 * 0xCCCC);
            await WriteSingleRegisterAsync(slaveAddress, 504, 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额定功率;
        }

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

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

        #endregion

        #region 四、实时测量

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

        public virtual async Task<double> 查询实时电流(double 额定电流, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 508, 1, ct);
            double current = reg[0] / (double)0xCCCC * 额定电流;
            if (await 查询Sink模式状态(slaveAddress, ct)) current = -current;
            return current;
        }

        public virtual async Task<double> 查询实时功率(double 额定功率, byte slaveAddress = 1, CancellationToken ct = default)
        {
            ushort[] reg = await ReadHoldingRegistersAsync(slaveAddress, 509, 1, ct);
            double power = reg[0] / (double)0xCCCC * 额定功率;
            if (await 查询Sink模式状态(slaveAddress, ct)) power = -power;
            return power;
        }

        #endregion

        #region 五、保护阈值

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

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

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

        #endregion
    }
}