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

namespace DeviceCommand.Device
{
    [BOBCommand]
    public class WS_68030_380T : ModbusTcp
    {
        public WS_68030_380T(string IpAddress, int port, int SendTimeout, int ReceiveTimeout)
        {
            ConfigureDevice(IpAddress, port, SendTimeout, ReceiveTimeout);
            ConnectAsync();
        }
        public WS_68030_380T()
        {
            ConnectAsync();
        }
        private const byte SlaveAddress = 1;

        #region 设置模式
        public async Task Set_Mode_LocalAuto(CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(SlaveAddress, 51, 0, ct);
        }

        public async Task Set_Mode_LocalManual(CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(SlaveAddress, 51, 1, ct);
        }

        public async Task Set_Mode_ATEControl(CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(SlaveAddress, 51, 2, ct);
        }

        public async Task Set_AlarmMute(CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(SlaveAddress, 52, 1, ct);
        }

        public async Task Set_FaultReset(CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(SlaveAddress, 53, 1, ct);
        }

        public async Task Set_SystemStop(CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(SlaveAddress, 54, 1, ct);
        }
        #endregion

        #region 负载模式
        public async Task Set_ATE_Load_CurrentMode(CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(SlaveAddress, 100, 0, ct);
        }

        public async Task Set_ATE_Load_PowerMode(CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(SlaveAddress, 100, 1, ct);
        }

        public async Task Set_ATE_Load_Uninstall(CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(SlaveAddress, 103, 0, ct);
        }

        public async Task Set_ATE_Load_Load(CancellationToken ct = default)
        {
            await WriteSingleRegisterAsync(SlaveAddress, 103, 1, ct);
        }
        #endregion

        #region 设置电流/功率
        public async Task Set_ATE_Load_A_Current(float current, CancellationToken ct = default)
        {
            var regs = ConvertFromFloat(current);
            await WriteMultipleRegistersAsync(SlaveAddress, 105, regs, ct);
        }

        public async Task Set_ATE_Load_A_Power(float power, CancellationToken ct = default)
        {
            var regs = ConvertFromFloat(power);
            await WriteMultipleRegistersAsync(SlaveAddress, 109, regs, ct);
        }

        public async Task Set_ATE_Load_B_Current(float current, CancellationToken ct = default)
        {
            var regs = ConvertFromFloat(current);
            await WriteMultipleRegistersAsync(SlaveAddress, 115, regs, ct);
        }

        public async Task Set_ATE_Load_B_Power(float power, CancellationToken ct = default)
        {
            var regs = ConvertFromFloat(power);
            await WriteMultipleRegistersAsync(SlaveAddress, 119, regs, ct);
        }

        public async Task Set_ATE_Load_C_Current(float current, CancellationToken ct = default)
        {
            var regs = ConvertFromFloat(current);
            await WriteMultipleRegistersAsync(SlaveAddress, 125, regs, ct);
        }

        public async Task Set_ATE_Load_C_Power(float power, CancellationToken ct = default)
        {
            var regs = ConvertFromFloat(power);
            await WriteMultipleRegistersAsync(SlaveAddress, 129, regs, ct);
        }
        #endregion

        #region 查询
        public async Task<float> Get_A_Voltage(CancellationToken ct = default)
        {
            var regs = await ReadHoldingRegistersAsync(SlaveAddress, 150, 2, ct);
            return ConvertToFloat(regs);
        }

        public async Task<float> Get_A_Current(CancellationToken ct = default)
        {
            var regs = await ReadHoldingRegistersAsync(SlaveAddress, 152, 2, ct);
            return ConvertToFloat(regs);
        }

        public async Task<float> Get_A_ActivePower(CancellationToken ct = default)
        {
            var regs = await ReadHoldingRegistersAsync(SlaveAddress, 154, 2, ct);
            return ConvertToFloat(regs);
        }

        // …同理其他相和三相测量，直接调用基类 ReadHoldingRegistersAsync
        #endregion

        #region 辅助方法
        private float ConvertToFloat(ushort[] values)
        {
            byte[] bytes = new byte[4];
            bytes[3] = (byte)(values[0] >> 8);
            bytes[2] = (byte)(values[0] & 0xFF);
            bytes[1] = (byte)(values[1] >> 8);
            bytes[0] = (byte)(values[1] & 0xFF);
            return BitConverter.ToSingle(bytes, 0);
        }

        private ushort[] ConvertFromFloat(float value)
        {
            byte[] bytes = BitConverter.GetBytes(value);
            return new ushort[]
            {
                (ushort)((bytes[3] << 8) | bytes[2]),
                (ushort)((bytes[1] << 8) | bytes[0])
            };
        }
        #endregion
    }
}