using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.ComponentModel.Design;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
using Team.FFFeederService.Enums;
using Team.FFFeederService.Interfaces;
using Team.FFFeederService.Models;
using TouchSocket.Core;
using TouchSocket.Sockets;

namespace Team.FFFeederService
{
    /// <summary>
    /// Feeder 参数读写控制
    /// </summary>
    public class TeamFeeder : IVoiceCoilMotorFeeder
    {
        #region 字段
        /// <summary>
        /// 背光打开命令
        /// </summary>
        private const string LightOpenCommand = "{K1}";
        /// <summary>
        /// 背光关闭命令
        /// </summary>
        private const string LightCloseCommand = "{K0}";
        /// <summary>
        /// 查询背光状态命令
        /// </summary>
        private const string QueryLightStateCommand = "{K?}";
        /// <summary>
        /// 平台振动参数起始地址
        /// </summary>
        private const int ShakeParamStartAddress = 300;
        /// <summary>
        /// 料斗振动参数起始地址
        /// </summary>
        private const int HopperParamStartAddress = 742;
        /// <summary>
        /// 序列参数起始地址
        /// </summary>
        private const int SequenceParamStartAddress = 950;

        private IWaitingClient<ITcpClient, IReceiverResult> WaitClient;

        private bool isFirstConnect = true;
        private Task bgConnectTask;
        #endregion

        #region 属性
        public FeederBrand FeederBrand { get => FeederBrand.TEAM; }

        public FeederModel FeederModel { get; private set; } = FeederModel.Unknown;

        public Guid Id { get; set; }
        /// <summary>
        /// Feeder连接状态
        /// </summary>
        public bool IsConnected => TcpClient.Online;

        /// <summary>
        /// Feeder是否首次连接成功
        /// </summary>
        public bool IsInit { get; private set; }
        /// <summary>
        /// Feeder IP地址
        /// </summary>
        public string FeederIp => TcpClient.IP;
        /// <summary>
        /// Feeder 端口
        /// </summary>
        public int FeederPort => TcpClient.Port;

        /// <summary>
        /// 接收数据的超时时间
        /// </summary>
        public int MillisecondsTimeout = 5000;  //接收数据超时时间

        /// <summary>
        /// TCP客户端通讯
        /// </summary>
        public TcpClient TcpClient { get; }
        #endregion
        // private const string SelectOneShakeCommand = "{UV1}\r\n";

        #region 事件
        /// <summary>
        /// Feeder连接上时
        /// </summary>
        public event Action<Guid, ITcpClient, ConnectedEventArgs> FeederConnectedEvent;
        /// <summary>
        /// Feeder断开连接上时
        /// </summary>
        public event Action<Guid, ITcpClient, ClosedEventArgs> FeederDisconnectedEvent;
        #endregion

        public TeamFeeder(TcpClient tcpClient)
        {
            TcpClient = tcpClient;
            //调用CreateWaitingClient获取到IWaitingClient的对象。
            WaitClient = tcpClient.CreateWaitingClient(new WaitingOptions()
            {
                FilterFunc = response => //设置用于筛选的fun委托，当返回为true时，才会响应返回
                {
                    return true;

                    //if (response.Data.Length == 1)
                    //{
                    //    return true;
                    //}
                    //return false;
                }
            });
            TcpClient.Connected = ConnectedVoid;
            TcpClient.Closed = DisconnectedVoid;
        }

        #region 方法

        #region Feeder 连接
        /// <summary>
        /// 连接Feeder
        /// </summary>
        public void Connect()
        {
            try
            {
                TcpClient.Connect();
                IsInit = true;
                isFirstConnect = false;
            }
            catch (Exception)
            {
                IsInit = false;
                if (bgConnectTask == null)
                {
                    bgConnectTask = Task.Run(async () =>
                    {
                        while (true)
                        {
                            try
                            {
                                TcpClient.Connect();
                                isFirstConnect = false;
                                return;
                            }
                            catch (Exception)
                            {
                                await Task.Delay(1000);
                            }
                        }
                    });
                }
                throw;
            }
        }

        /// <summary>
        /// 连接Feeder
        /// </summary>
        /// <returns></returns>
        public async Task ConnectAsync()
        {
            try
            {
                await TcpClient.ConnectAsync();
                IsInit = true;
                isFirstConnect = false;
            }
            catch (Exception)
            {
                IsInit = false;
                if (bgConnectTask == null)
                {
                    bgConnectTask = Task.Run(async () =>
                    {
                        while (true)
                        {
                            try
                            {
                                TcpClient.Connect();
                                isFirstConnect = false;
                                return;
                            }
                            catch (Exception)
                            {
                                await Task.Delay(1000);
                            }
                        }
                    });
                }
                throw;
            }
        }
        #endregion

        public void Reset()
        {

        }
        public Task ResetAsync()
        {
            return Task.CompletedTask;
        }

        #region 振动集
        /// <summary>
        /// 选择使用振动集
        /// </summary>
        /// <param name="id"></param>
        /// <exception cref="FeederResponseException"></exception>
        public void SelectShakeParam(int id)
        {
            var sendCommand = "{UV" + id + "}";
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            if (result.TrimEnd() != sendCommand.TrimEnd())
            {
                throw new Exception("FFFeeder响应不正确");
            }
        }

        /// <summary>
        /// 选择使用振动集
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        /// <exception cref="FeederResponseException"></exception>
        public async Task SelectShakeParamAsync(int id)
        {
            var sendCommand = "{UV" + id + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            if (result.TrimEnd() != sendCommand.TrimEnd())
            {
                throw new Exception("FFFeeder响应不正确");
            }
        }

        /// <summary>
        /// 将振动集参数存储至非易失内存中
        /// </summary>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public async Task SaveShakeSetAsync()
        {
            string sendCommand = "{DV}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            if (result.TrimEnd() != sendCommand.TrimEnd())
            {
                throw new Exception("FFFeeder响应不正确");
            }
        }

        /// <summary>
        /// 查询当前选择的振动集
        /// </summary>
        /// <returns></returns>
        public int GetSelectedShakeParam()
        {
            const string sendCommand = "{UV?}";
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            return int.Parse(result.TrimEnd().Split(':')[1].Replace("}", ""));
        }

        /// <summary>
        /// 查询当前选择的振动集
        /// </summary>
        /// <returns></returns>
        public async Task<int> GetSelectedShakeParamAsync()
        {
            const string sendCommand = "{UV?}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            return int.Parse(result.TrimEnd().Split(':')[1].Replace("}", ""));
        }
        #endregion

        #region 平台振动参数
        //300~741
        //300   A   平台振动 A 振幅 1
        //301   A   平台振动 A 频率 1
        //302   A   平台振动 A 相位 1
        //303   A   平台振动 A 波形 1
        //304   A   平台振动 A 振幅 2
        //305   A   平台振动 A 频率 2
        //306   A   平台振动 A 相位 2
        //307   A   平台振动 A 波形 2
        //308   A   平台振动 A 振幅 3
        //309   A   平台振动 A 频率 3
        //310   A   平台振动 A 相位 3
        //311   A   平台振动 A 波形 3
        //312   A   平台振动 A 振幅 4
        //313   A   平台振动 A 频率 4
        //314   A   平台振动 A 相位 4
        //315   A   平台振动 A 波形 4
        //316   A   平台振动 A 持续时间
        //300+17*n

        /// <summary>
        /// 选择要使用的振动集(1~26)
        /// </summary>
        /// <param name="v"></param>
        /// <returns></returns>
        public bool LoadShakeSet(int v)
        {
            var command = "{UV" + v + "}";
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command));
            string result = Encoding.ASCII.GetString(returnData);
            return result == command;
        }

        /// <summary>
        /// 选择要使用的振动集(1~26)
        /// </summary>
        /// <param name="v"></param>
        /// <returns></returns>
        public async Task<bool> LoadShakeSetAsync(int v)
        {
            var command = "{UV" + v + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            string result = Encoding.ASCII.GetString(returnData);

            return result == command;
        }

        /// <summary>
        /// 执行平台振动
        /// </summary>
        /// <param name="index"></param>
        /// <param name="timespan"></param>
        public async Task<int> StartAction(int index, int? timespan = null)
        {
            if (index < 0 || index > 25)
            {
                index = 0;
            }
            char chn = (char)('A' + index);
            string actionCommand = $"C{chn}";
            return await RunFromCommand(actionCommand, timespan);
        }

        /// <summary>
        /// 停止平台振动
        /// </summary>
        public void Stop()
        {
            WaitClient.SendThenReturn(Encoding.ASCII.GetBytes("{HC}"), MillisecondsTimeout);
        }

        /// <summary>
        /// 停止平台振动
        /// </summary>
        /// <returns></returns>
        public Task StopAsync()
        {
            return WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes("{HC}"), MillisecondsTimeout);
        }

        /// <summary>
        /// 向前
        /// </summary>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunToLeftAsync(int? timespan = null)
        {
            var command = "{CA" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CA", "");
            if (string.IsNullOrEmpty(timeSpan))
            {
                return 0;
            }
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 左前
        /// </summary>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunToBottomLeftAsync(int? timespan = null)
        {

            var command = "{CB" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CB", "");
            if (string.IsNullOrEmpty(timeSpan))
            {
                return 0;
            }
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 右前
        /// </summary>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunToTopLeftAsync(int? timespan = null)
        {
            var command = "{CC" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CC", "");
            if (string.IsNullOrEmpty(timeSpan))
            {
                return 0;
            }
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 向左
        /// </summary>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunToBottomAsync(int? timespan = null)
        {
            var command = "{CD" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CD", "");
            if (string.IsNullOrEmpty(timeSpan))
            {
                return 0;
            }
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 向右
        /// </summary>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunToTopAsync(int? timespan = null)
        {
            var command = "{CE" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CE", "");
            if (string.IsNullOrEmpty(timeSpan))
            {
                return 0;
            }
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 向后
        /// </summary>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunToRightAsync(int? timespan = null)
        {
            var command = "{CF" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CF", "");
            if (string.IsNullOrEmpty(timeSpan))
            {
                return 0;
            }
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 左后
        /// </summary>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunToBottomRightAsync(int? timespan = null)
        {
            var command = "{CG" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CG", "");
            if (string.IsNullOrEmpty(timeSpan))
            {
                return 0;
            }
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 右后
        /// </summary>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunToTopRightAsync(int? timespan = null)
        {
            var command = "{CH" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CH", "");
            if (string.IsNullOrEmpty(timeSpan))
            {
                return 0;
            }
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 散开
        /// </summary>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunToFlipAsync(int? timespan = null)
        {

            var command = "{CI" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CI", "");
            return string.IsNullOrEmpty(timeSpan) ? 0 : int.Parse(timeSpan);
        }

        /// <summary>
        /// 横向聚中
        /// </summary>
        /// <param name="timespan">持续时间</param>
        /// <returns></returns>
        public async Task<int> RunToInnerVerticalAsync(int? timespan = null)
        {
            var command = "{CJ" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CJ", "");
            if (string.IsNullOrEmpty(timeSpan))
            {
                return 0;
            }
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 纵向聚中
        /// </summary>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunToInnerHorizonAsync(int? timespan = null)
        {
            var command = "{CK" + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("CK", "");
            if (string.IsNullOrEmpty(timeSpan))
            {
                return 0;
            }
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 读一个振动动作值
        /// </summary>
        /// <param name="v"></param>
        /// <returns></returns>
        public SingleActionParam GetShakeGroupValue(int index)
        {
            if (index < 0 || index > 25)
            {
                index = 0;
            }
            return GetShakeGroupValueAsync(index).GetAwaiter().GetResult();
        }

        /// <summary>
        /// 读一个振动动作值
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public async Task<SingleActionParam> GetShakeGroupValueAsync(int index)
        {
            var results = new string[17];
            for (var j = 0; j < 17; j++)
            {
                var id = index * 17 + ShakeParamStartAddress + j;
                var command = "{RP" + id + "}";
                var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
                string result = Encoding.ASCII.GetString(returnData);
                results[j] = result.TrimEnd().Replace("{RP", "").Replace("}", "").Split(":")[1];
            }
            int i = 0;
            SingleActionParam actionParam=new SingleActionParam();
            actionParam.Motor1 = new VoiceMotorParam() { Amplitude = ushort.Parse(results[i]), Frequency= ushort.Parse(results[i+1]), Phase = ushort.Parse(results[i + 2]), WaveShape= (WaveShape)ushort.Parse(results[i + 3]) };
            i = 4;
            actionParam.Motor2 = new VoiceMotorParam() { Amplitude = ushort.Parse(results[i]), Frequency = ushort.Parse(results[i + 1]), Phase = ushort.Parse(results[i + 2]), WaveShape = (WaveShape)ushort.Parse(results[i + 3]) };
            i = 8;
            actionParam.Motor3 = new VoiceMotorParam() { Amplitude = ushort.Parse(results[i]), Frequency = ushort.Parse(results[i + 1]), Phase = ushort.Parse(results[i + 2]), WaveShape = (WaveShape)ushort.Parse(results[i + 3]) };
            i = 12;
            actionParam.Motor4 = new VoiceMotorParam() { Amplitude = ushort.Parse(results[i]), Frequency = ushort.Parse(results[i + 1]), Phase = ushort.Parse(results[i + 2]), WaveShape = (WaveShape)ushort.Parse(results[i + 3]) };
            actionParam.DurationValue = int.Parse(results[16]);
            return actionParam;
        }

        /// <summary>
        /// 获取单个动作持续时间
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int GetDuration(int id)
        {
            var idInServer = id * 17 + 316;
            var command = "{RP" + idInServer + "}";
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command));
            string result = Encoding.ASCII.GetString(returnData);
            var value = result.TrimEnd().Replace("{RP", "").Replace("}", "").Split(':')[1];
            return int.Parse(value);
        }

        /// <summary>
        /// 获取单个动作持续时间
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<int> GetDurationAsync(int id)
        {
            var idInServer = id * 17 + 316;
            var command = "{RP" + idInServer + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            string result = Encoding.ASCII.GetString(returnData);
            var value = result.TrimEnd().Replace("{RP", "").Replace("}", "").Split(':')[1];
            return int.Parse(value);
        }

        /// <summary>
        /// 写入振动单个参数
        /// </summary>
        /// <param name="selectedShakeMotion"></param>
        /// <param name="id"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task SetShakeParametersAsync(int selectedShakeMotion, int id, string value)
        {
            var commandId = 300 + selectedShakeMotion * 17 + id;
            var command = "{WP" + $"{commandId}={value}" + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            //string result = Encoding.ASCII.GetString(returnData);
        }

        /// <summary>
        /// 写入振动单个参数
        /// </summary>
        /// <param name="selectedShakeMotion"></param>
        /// <param name="id"></param>
        /// <param name="value"></param>
        public void SetShakeParameters(int selectedShakeMotion, int id, string value)
        {
            var commandId = 300 + selectedShakeMotion * 17 + id;
            var command = "{WP" + $"{commandId}={value}" + "}";
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command));
        }

        /// <summary>
        /// 写入平台振动完成参数
        /// </summary>
        /// <param name="selectedShakeMotion"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task SetShakeParametersAsync(int selectedShakeMotion, string value)
        {
            if (selectedShakeMotion < 0 || selectedShakeMotion > 15)
                selectedShakeMotion = 0;
            char chn = (char)('A' + selectedShakeMotion);
            var command = "{SC" + $"{chn}=" + $"({value})" + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
        }

        /// <summary>
        /// 写入平台振动完成参数
        /// </summary>
        /// <param name="selectedShakeMotion"></param>
        /// <param name="value"></param>
        public void SetShakeParameters(int selectedShakeMotion, string value)
        {
            if (selectedShakeMotion < 0 || selectedShakeMotion > 15)
                selectedShakeMotion = 0;
            char chn = (char)('A' + selectedShakeMotion);
            var command = "{SC" + $"{chn}=" + $"({value})" + "}";
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command));
        }

        /// <summary>
        /// 写入完整的平台振动参数
        /// </summary>
        /// <param name="selectedShakeMotion"></param>
        /// <param name="value"></param>
        public void SetShakeParameters(int selectedShakeMotion, SingleActionParam value)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append($"{value.Motor1.Amplitude};{value.Motor1.Frequency};{value.Motor1.Phase};{(int)value.Motor1.WaveShape};");
            sb.Append($"{value.Motor2.Amplitude};{value.Motor2.Frequency};{value.Motor2.Phase};{(int)value.Motor2.WaveShape};");
            sb.Append($"{value.Motor3.Amplitude};{value.Motor3.Frequency};{value.Motor3.Phase};{(int)value.Motor3.WaveShape};");
            sb.Append($"{value.Motor4.Amplitude};{value.Motor4.Frequency};{value.Motor4.Phase};{(int)value.Motor4.WaveShape};");
            sb.Append($"{value.DurationValue}");
            SetShakeParameters(selectedShakeMotion, sb.ToString());
        }

        /// <summary>
        /// 写入完整的平台振动参数
        /// </summary>
        /// <param name="selectedShakeMotion"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        public async Task SetShakeParametersAsync(int selectedShakeMotion, SingleActionParam value)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append($"{value.Motor1.Amplitude};{value.Motor1.Frequency};{value.Motor1.Phase};{(int)value.Motor1.WaveShape};");
            sb.Append($"{value.Motor2.Amplitude};{value.Motor2.Frequency};{value.Motor2.Phase};{(int)value.Motor2.WaveShape};");
            sb.Append($"{value.Motor3.Amplitude};{value.Motor3.Frequency};{value.Motor3.Phase};{(int)value.Motor3.WaveShape};");
            sb.Append($"{value.Motor4.Amplitude};{value.Motor4.Frequency};{value.Motor4.Phase};{(int)value.Motor4.WaveShape};");
            sb.Append($"{value.DurationValue}");
            await SetShakeParametersAsync(selectedShakeMotion, sb.ToString());
        }

        /// <summary>
        /// 获取完整的平台振动参数
        /// </summary>
        /// <param name="selectedShakeMotion"></param>
        /// <returns></returns>
        public SingleActionParam GetShakeParameters(int selectedShakeMotion)
        {
            if (selectedShakeMotion < 0 || selectedShakeMotion > 15)
                selectedShakeMotion = 0;
            char chn = (char)('A' + selectedShakeMotion);
            var command = "{LC" + $"{chn}" + "}";
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command));
            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace($"LC{chn}", "").Replace("(", "").Replace(")", "").Replace(":", "").Split(";");
            int i = 0;
            SingleActionParam actionParam = new SingleActionParam();
            actionParam.Motor1 = new VoiceMotorParam() { Amplitude = ushort.Parse(timeSpan[i]), Frequency = ushort.Parse(timeSpan[i + 1]), Phase = ushort.Parse(timeSpan[i + 2]), WaveShape = (WaveShape)ushort.Parse(timeSpan[i + 3]) };
            i = 4;
            actionParam.Motor2 = new VoiceMotorParam() { Amplitude = ushort.Parse(timeSpan[i]), Frequency = ushort.Parse(timeSpan[i + 1]), Phase = ushort.Parse(timeSpan[i + 2]), WaveShape = (WaveShape)ushort.Parse(timeSpan[i + 3]) };
            i = 8;
            actionParam.Motor2 = new VoiceMotorParam() { Amplitude = ushort.Parse(timeSpan[i]), Frequency = ushort.Parse(timeSpan[i + 1]), Phase = ushort.Parse(timeSpan[i + 2]), WaveShape = (WaveShape)ushort.Parse(timeSpan[i + 3]) };
            i = 12;
            actionParam.Motor2 = new VoiceMotorParam() { Amplitude = ushort.Parse(timeSpan[i]), Frequency = ushort.Parse(timeSpan[i + 1]), Phase = ushort.Parse(timeSpan[i + 2]), WaveShape = (WaveShape)ushort.Parse(timeSpan[i + 3]) };
            actionParam.DurationValue = int.Parse(timeSpan[16]);
            return actionParam;
        }

        /// <summary>
        /// 获取完整的平台振动参数
        /// </summary>
        /// <param name="selectedShakeMotion"></param>
        /// <returns></returns>
        public async Task<SingleActionParam> GetShakeParametersAsync(int selectedShakeMotion)
        {
            if (selectedShakeMotion < 0 || selectedShakeMotion > 15)
                selectedShakeMotion = 0;
            char chn = (char)('A' + selectedShakeMotion);
            var command = "{LC" + $"{chn}" + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace($"LC{chn}", "").Replace("(", "").Replace(")", "").Replace(":", "").Split(";");
            int i = 0;
            SingleActionParam actionParam = new SingleActionParam();
            actionParam.Motor1 = new VoiceMotorParam() { Amplitude = ushort.Parse(timeSpan[i]), Frequency = ushort.Parse(timeSpan[i + 1]), Phase = ushort.Parse(timeSpan[i + 2]), WaveShape = (WaveShape)ushort.Parse(timeSpan[i + 3]) };
            i = 4;
            actionParam.Motor2 = new VoiceMotorParam() { Amplitude = ushort.Parse(timeSpan[i]), Frequency = ushort.Parse(timeSpan[i + 1]), Phase = ushort.Parse(timeSpan[i + 2]), WaveShape = (WaveShape)ushort.Parse(timeSpan[i + 3]) };
            i = 8;
            actionParam.Motor2 = new VoiceMotorParam() { Amplitude = ushort.Parse(timeSpan[i]), Frequency = ushort.Parse(timeSpan[i + 1]), Phase = ushort.Parse(timeSpan[i + 2]), WaveShape = (WaveShape)ushort.Parse(timeSpan[i + 3]) };
            i = 12;
            actionParam.Motor2 = new VoiceMotorParam() { Amplitude = ushort.Parse(timeSpan[i]), Frequency = ushort.Parse(timeSpan[i + 1]), Phase = ushort.Parse(timeSpan[i + 2]), WaveShape = (WaveShape)ushort.Parse(timeSpan[i + 3]) };
            actionParam.DurationValue = int.Parse(timeSpan[16]);
            return actionParam;
        }

        /// <summary>
        /// 获取平台震动超时时间
        /// </summary>
        /// <returns></returns>
        public async Task<ushort> GetPlatShakeTimeoutAsync()
        {
            const string sendCommand = "{RP65?}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            return ushort.Parse(result.TrimEnd().Split(':')[1].Replace("}", ""));
        }

        /// <summary>
        /// 设置平台震动超时时间
        /// </summary>
        /// <param name="upperFeederShakeTimeout"></param>
        /// <returns></returns>
        public async Task SetPlatShakeTimeoutAsync(ushort upperFeederShakeTimeout)
        {
            const int commandId = 65;
            var command = "{WP" + $"{commandId}={upperFeederShakeTimeout}" + "}";
            var result = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            //const string saveCommand = "{DG}";
            //var result1 = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(saveCommand));
        }
        #endregion

        #region 料斗振动输出参数
        //742~949
        //742+8*n   n   料斗动作 n 数字量输出 1
        //743+8*n   n   料斗动作 n 模拟量输出 1
        //744+8*n   n   料斗动作 n 数字量输出 2
        //745+8*n   n   料斗动作 n 模拟量输出 2
        //746+8*n   n   备用
        //747+8*n   n   备用
        //748+8*n   n   备用
        //749+8*n   n   料斗振动 n 持续时间

        /// <summary>
        /// 执行料斗供料
        /// </summary>
        /// <returns></returns>
        public async Task<int> ShakeUpAsync()
        {
            const string sendCommand = "{EF:(A;55;110)}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            return ushort.Parse(result.TrimEnd().Split(';')[1].Replace("}", "").Replace(")", ""));
        }

        /// <summary>
        /// 执行供料
        /// </summary>
        /// <returns></returns>
        public int ShakeUp()
        {
            const string sendCommand = "{EF:(A;55;110)}";
            var result = Encoding.ASCII.GetString(WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(sendCommand)));
            return ushort.Parse(result.TrimEnd().Split(';')[1].Replace("}", "").Replace(")", ""));
        }

        /// <summary>
        /// 停止料斗振动
        /// </summary>
        /// <returns></returns>
        public Task StopOutputAsync()
        {
            const string command = "{HB}";
            return WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
        }

        /// <summary>
        /// 停止料斗振动
        /// </summary>
        public void StopOutput()
        {
            const string command = "{HB}";
            WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command));
        }

        /// <summary>
        /// 获取料斗参数
        /// </summary>
        /// <param name="selectedSequence"></param>
        /// <returns></returns>
        public async Task<HopperFeederParam> GetUpperParamAsync(int selectedSequence)
        {
            var param = new HopperFeederParam();
            var startIndex = 742 + selectedSequence * 8;
            var collections = new string[8];
            for (var i = 0; i < 8; i++)
            {
                var id = startIndex + i;
                var result = await GetSingleParamValueAsync(id);
                collections[i] = result.Replace("{", "").Replace("}", "").Split(':')[1];
            }

            param.HopperDigitalOutput1 = int.Parse(collections[0]) == 1;
            param.HopperAnalogOutput1 = int.Parse(collections[1]);
            param.HopperDigitalOutput2 = int.Parse(collections[2]) == 1;
            param.HopperAnalogOutput2 = int.Parse(collections[3]);
            param.HopperVibrationAmpl = int.Parse(collections[4]);
            param.HopperVibrationFreq = int.Parse(collections[5]);
            param.HopperVibrationWaveform = int.Parse(collections[6]);
            param.HopperDuration = int.Parse(collections[7]);
            return param;
            //return ushort.Parse(result.Split(':')[1].Replace("}", ""));
        }

        /// <summary>
        /// 写入输出参数
        /// </summary>
        /// <param name="groupId"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public async Task WriteOutputParamAsync(int groupId, HopperFeederParam param)
        {
            const int startId = 742;
            var id1 = startId + groupId * 8;
            var id2 = startId + groupId * 8 + 1;
            var id3 = startId + groupId * 8 + 2;
            var id4 = startId + groupId * 8 + 3;
            var id5 = startId + groupId * 8 + 7;
            var command1 = "{WP" + $"{id1}={Convert.ToInt32(param.HopperDigitalOutput1)}" + "}";
            var command2 = "{WP" + $"{id2}={Convert.ToInt32(param.HopperAnalogOutput1)}" + "}";
            var command3 = "{WP" + $"{id3}={Convert.ToInt32(param.HopperDigitalOutput2)}" + "}";
            var command4 = "{WP" + $"{id4}={Convert.ToInt32(param.HopperAnalogOutput2)}" + "}";
            var command5 = "{WP" + $"{id5}={Convert.ToInt32(param.HopperDuration)}" + "}";
            var result1 = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command1));
            var result2 = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command2));
            var result3 = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command3));
            var result4 = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command4));
            var result5 = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command5));
            await SaveShakeSetAsync();
        }

        /// <summary>
        /// 获取料斗震动超时时间
        /// </summary>
        /// <returns></returns>
        public async Task<ushort> GetUpperFeederShakeTimeoutAsync()
        {
            const string sendCommand = "{RP66?}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            return ushort.Parse(result.TrimEnd().Split(':')[1].Replace("}", ""));
        }

        /// <summary>
        /// 设置料斗震动超时时间
        /// </summary>
        /// <param name="upperFeederShakeTimeout"></param>
        /// <returns></returns>
        public async Task SetUpperFeederShakeTimeoutAsync(ushort upperFeederShakeTimeout)
        {
            const int commandId = 66;
            var command = "{WP" + $"{commandId}={upperFeederShakeTimeout}" + "}";
            var result = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            //const string saveCommand = "{DG}";
            //var result1 = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(saveCommand));
        }

        /// <summary>
        /// 执行料斗动作
        /// </summary>
        /// <param name="id"></param>
        /// <param name="timespan"></param>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public async Task<int> OutputAsync(int id, int? timespan = null)
        {
            if (id < 1 || id > 26)
            {
                throw new Exception("输入参数不正确");
            }

            var enumerable = Enumerable.Range('A', 26).ToArray();
            //var split = new[] { "A", "B" };
            var outPut = "B" + (char)enumerable[id - 1];
            var command = "{" + outPut + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace(outPut, "");
            return string.IsNullOrWhiteSpace(timeSpan) ? 0 : int.Parse(timeSpan);

        }

        /// <summary>
        /// 执行料斗动作
        /// </summary>
        /// <param name="id"></param>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public int Output(int id, int? timespan = null)
        {
            var enumerable = Enumerable.Range('A', 26).ToArray();
            //var split = new[] { "A", "B" };
            var outPut = "B" + (char)enumerable[id - 1];
            var command = "{" + outPut + timespan + "}";
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command));
            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace(outPut, "");
            return int.Parse(timeSpan);
        }

        /// <summary>
        /// 获取取料斗动作状态
        /// </summary>
        /// <returns></returns>
        public bool GetOutputStatus()
        {
            const string sendCommand = "{RP97?}";
            var result = Encoding.ASCII.GetString(WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(sendCommand)));
            return result.Split(':')[1].Replace("}", "") == "0" ? false : true;
        }

        /// <summary>
        ///获取取料斗动作状态
        /// </summary>
        /// <returns></returns>
        public async Task<bool> GetOutputStatusAsync()
        {
            const string sendCommand = "{RP97?}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            return result.Split(':')[1].Replace("}", "") == "0" ? false : true;
        }
        #endregion

        #region 序列动作参数
        //950~1703
        //950+29*n  n   动作 1 类型
        //951+29*n  n   动作 1 震动
        //952+29*n  n   动作 1 持续模式
        //953+29*n  n   动作 1 持续时间值
        //954+29*n  n   动作 2 类型
        //955+29*n  n   动作 2 震动
        //956+29*n  n   动作 2 持续模式
        //957+29*n  n   动作 2 持续时间值
        //958+29*n  n   动作 3 类型
        //959+29*n  n   动作 3 震动
        //960+29*n  n   动作 3 持续模式
        //961+29*n  n   动作 3 持续时间值
        //962+29*n  n   动作 4 类型
        //963+29*n  n   动作 4 震动
        //964+29*n  n   动作 4 持续模式
        //965+29*n  n   动作 4 持续时间值
        //966+29*n  n   动作 5 类型
        //967+29*n  n   动作 5 震动
        //968+29*n  n   动作 5 持续模式
        //969+29*n  n   动作 5 持续时间值
        //970+29*n  n   动作 6 类型
        //971+29*n  n   动作 6 震动
        //972+29*n  n   动作 6 持续模式
        //973+29*n  n   动作 6 持续时间值
        //974+29*n  n   动作 7 类型
        //975+29*n  n   动作 7 震动
        //976+29*n  n   动作 7 持续模式
        //977+29*n  n   动作 7 持续时间值
        //978+29*n  n   震动平台零件极限值

        /// <summary>
        /// 停止序列
        /// </summary>
        /// <returns></returns>
        public async Task StopOneSequenceAsync()
        {
            var sendCommand = "{HS}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            //string result = Encoding.ASCII.GetString(returnData);
        }

        /// <summary>
        /// 执行一个序列
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<int> StartOneSequenceAsync(int id)
        {
            var sendCommand = "{ES:(0;0;0;0;" + id + ")}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            var replaced = result.TrimEnd().Replace("{", "").Replace("}", "").Replace("(", "").Replace(")", "");
            var splits = replaced.Split(';');
            return int.Parse(splits[5]);
            //#if NETCOREAPP
            //            var time = int.Parse(splits[^1]);
            //            return time;
            //#elif NET472||NETSTANDARD
            //  var time = int.Parse(splits[splits.Length - 1]);
            //            return time;
            //#endif
        }

        /// <summary>
        /// 获取单个序列集
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<SingleSequenceActionGroup> GetSequenceGroupAsync(int id)
        {
            const int startId = SequenceParamStartAddress;
            var singleSequenceActionGroup = new SingleSequenceActionGroup();
            singleSequenceActionGroup.SingleSequenceActions = new System.Collections.ObjectModel.ObservableCollection<SingleSequenceAction>();
            for (var i = 0; i < 7; i++)
            {
                var singleSequenceAction = new SingleSequenceAction();
                var value1 = await GetSingleParamValueAsync(startId + id * 29 + i * 4);
                var value2 = await GetSingleParamValueAsync(startId + id * 29 + i * 4 + 1);
                var value3 = await GetSingleParamValueAsync(startId + id * 29 + i * 4 + 2);
                var value4 = await GetSingleParamValueAsync(startId + id * 29 + i * 4 + 3);
                value1 = value1.Replace("{", "");
                value1 = value1.Replace("}", "").Split(':')[1];
                value2 = value2.Replace("{", "");
                value2 = value2.Replace("}", "").Split(':')[1];
                value3 = value3.Replace("{", "");
                value3 = value3.Replace("}", "").Split(':')[1];
                value4 = value4.Replace("{", "");
                value4 = value4.Replace("}", "").Split(':')[1];
                singleSequenceAction.Type = (ActionType)int.Parse(value1);
                singleSequenceAction.ShakeId = int.Parse(value2) > 0 ? int.Parse(value2) : 0;
                singleSequenceAction.DurationMode = (DurationMode)int.Parse(value3);
                singleSequenceAction.DurationValue = int.Parse(value4);

                singleSequenceActionGroup.SingleSequenceActions.Add(singleSequenceAction);
            }

            var value5 = await GetSingleParamValueAsync(startId + id * 29 + 28);
            value5 = value5.Replace("{", "");
            value5 = value5.Replace("}", "").Split(':')[1];
            singleSequenceActionGroup.PartCntMax = int.Parse(value5);
            return singleSequenceActionGroup;
        }

        /// <summary>
        /// 写入序列参数
        /// </summary>
        /// <param name="groupId"></param>
        /// <param name="singleSequenceAction"></param>
        public void SetSequence(int groupId, int actionId, SingleSequenceAction singleSequenceAction)
        {
            const int startId = SequenceParamStartAddress;
            var id1 = startId + groupId * 29 + actionId * 4;
            var id2 = startId + groupId * 29 + actionId * 4 + 1;
            var id3 = startId + groupId * 29 + actionId * 4 + 2;
            var id4 = startId + groupId * 29 + actionId * 4 + 3;
            var command1 = "{WP" + $"{id1}={(int)singleSequenceAction.Type}" + "}";
            var command2 = "{WP" + $"{id1}={singleSequenceAction.ShakeId}" + "}";
            var command3 = "{WP" + $"{id1}={(int)singleSequenceAction.DurationMode}" + "}";
            var command4 = "{WP" + $"{id1}={(int)singleSequenceAction.DurationValue}" + "}";

            var result = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command1));
            result = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command2));
            result = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command3));
            result = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command4));
        }

        /// <summary>
        /// 写入序列参数
        /// </summary>
        /// <param name="groupId"></param>
        /// <param name="actionId"></param>
        /// <param name="singleSequenceAction"></param>
        /// <returns></returns>
        public async Task SetSequenceAsync(int groupId, int actionId, SingleSequenceAction singleSequenceAction)
        {
            const int startId = 950;
            var id1 = startId + groupId * 29 + actionId * 4;
            var id2 = startId + groupId * 29 + actionId * 4 + 1;
            var id3 = startId + groupId * 29 + actionId * 4 + 2;
            var id4 = startId + groupId * 29 + actionId * 4 + 3;
            var command1 = "{WP" + $"{id1}={(int)singleSequenceAction.Type}" + "}";
            var command2 = "{WP" + $"{id2}={singleSequenceAction.ShakeId}" + "}";
            var command3 = "{WP" + $"{id3}={(int)singleSequenceAction.DurationMode}" + "}";
            var command4 = "{WP" + $"{id4}={singleSequenceAction.DurationValue}" + "}";

            var result = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command1));
            result = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command2));
            result = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command3));
            result = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command4));
        }

        /// <summary>
        /// 将序列参数存储至非易失内存中
        /// </summary>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public async Task SaveSequenceAsync()
        {
            const string sendCommand = "{DS}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            if (result.TrimEnd() != sendCommand.TrimEnd())
            {
                throw new Exception("FFFeeder响应不正确");
            }
        }

        /// <summary>
        /// 查询当前选择的序列
        /// </summary>
        /// <returns></returns>
        public int GetSelectedSequence()
        {
            const string sendCommand = "{US?}";
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);

            return int.Parse(result.TrimEnd().Split(':')[1].Replace("}", ""));
        }

        /// <summary>
        /// 查询当前选择的序列
        /// </summary>
        /// <returns></returns>
        public async Task<int> GetSelectedSequenceAsync()
        {
            const string sendCommand = "{US?}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);

            return int.Parse(result.TrimEnd().Split(':')[1].Replace("}", ""));
        }
        #endregion

        #region 背光灯操作
        /// <summary>
        /// 背光灯打开
        /// </summary>
        public void OpenLight()
        {
            WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(LightOpenCommand), MillisecondsTimeout);
        }

        /// <summary>
        /// 背光灯打开
        /// </summary>
        /// <returns></returns>
        public Task OpenLightAsync()
        {
            return WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(LightOpenCommand), MillisecondsTimeout);
        }

        /// <summary>
        /// 背光关闭
        /// </summary>
        public void CloseLight()
        {
            WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(LightCloseCommand), MillisecondsTimeout);
        }

        /// <summary>
        /// 背光关闭
        /// </summary>
        /// <returns></returns>
        public Task CloseLightAsync()
        {
            return WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(LightCloseCommand), MillisecondsTimeout);
        }

        /// <summary>
        /// 设置背光打开超时时间
        /// </summary>
        /// <param name="timeout"></param>
        public void SetLightTimeOut(ushort timeout)
        {
            var commandId = 44;
            var command = "{WP" + $"{commandId}={timeout}" + "}";
            var result = Encoding.ASCII.GetString(WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command)));
            //var saveCommand = "{DG}";
            //var result1 = Encoding.ASCII.GetString(WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(saveCommand)));
        }

        /// <summary>
        /// 设置背光打开超时时间
        /// </summary>
        /// <param name="timeout"></param>
        /// <returns></returns>
        public async Task SetLightTimeOutAsync(ushort timeout)
        {
            var commandId = 44;
            var command = "{WP" + $"{commandId}={timeout}" + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            string result = Encoding.ASCII.GetString(returnData);
            //var saveCommand = "{DG}";
            //returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(saveCommand));
        }

        /// <summary>
        /// 获取背光打开超时时间
        /// </summary>
        /// <returns></returns>
        public ushort GetLightTimeout()
        {
            const string sendCommand = "{RP44?}";
            var result = Encoding.ASCII.GetString(WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(sendCommand)));
            return ushort.Parse(result.Split(':')[1].Replace("}", ""));
        }

        /// <summary>
        /// 获取背光打开超时时间
        /// </summary>
        /// <returns></returns>
        public async Task<ushort> GetLightTimeoutAsync()
        {
            const string sendCommand = "{RP44?}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            return ushort.Parse(result.TrimEnd().Split(':')[1].Replace("}", ""));
        }

        /// <summary>
        /// 设置背光亮度
        /// </summary>
        /// <param name="lightValue"></param>
        /// <returns></returns>
        public async Task SetLightValueAsync(ushort lightValue)
        {
            const int commandId = 34;
            var command = "{WP" + $"{commandId}={lightValue}" + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            string result = Encoding.ASCII.GetString(returnData);
            //const string saveCommand = "{DG}";
            //returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(saveCommand));
            //result = Encoding.ASCII.GetString(returnData);
        }

        /// <summary>
        /// 设置背光亮度
        /// </summary>
        /// <param name="lightValue"></param>
        /// <returns></returns>
        public async Task SetLightValueToBufferAsync(ushort lightValue)
        {
            const int commandId = 34;
            var command = "{WP" + $"{commandId}={lightValue}" + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            //string result = Encoding.ASCII.GetString(returnData);
        }

        /// <summary>
        /// 设置背光闪烁时间
        /// </summary>
        /// <param name="backLightFlash"></param>
        /// <returns></returns>
        public async Task SetBackLightFlashTimeAsync(ushort backLightFlash)
        {
            const int commandId = 33;
            var command = "{WP" + $"{commandId}={backLightFlash}" + "}";
            var result = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            //const string saveCommand = "{DG}";
            //var result1 = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(saveCommand));
        }

        /// <summary>
        /// 获取背光状态
        /// </summary>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public bool QueryLightState()
        {
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(QueryLightStateCommand));

            string result = Encoding.ASCII.GetString(returnData);
            result = result.Trim().Replace("{", "").Replace("}", "");
            var splitsStrings = result.Split(':');
            if (splitsStrings.Length <= 1)
            {
                throw new Exception("RECEIVED DATA NOT CORRECT");
            }

            return splitsStrings[1] == "1";
        }

        /// <summary>
        /// 获取背光状态
        /// </summary>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public async Task<bool> QueryLightStateAsync()
        {
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(QueryLightStateCommand));

            string result = Encoding.ASCII.GetString(returnData);
            result = result.Trim().Replace("{", "").Replace("}", "");
            var splitsStrings = result.Split(':');
            if (splitsStrings.Length <= 1)
            {
                throw new Exception("RECEIVED DATA NOT CORRECT");
            }

            return splitsStrings[1] == "1";
        }

        /// <summary>
        /// 获取背光亮度
        /// </summary>
        /// <returns></returns>
        public async Task<ushort> GetLightBrightnessAsync()
        {
            const string sendCommand = "{RP34?}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            return ushort.Parse(result.TrimEnd().Split(':')[1].Replace("}", ""));
        }

        /// <summary>
        /// 获取背光闪烁时间
        /// </summary>
        /// <returns></returns>
        public async Task<ushort> GetBackLightFlashTimeAsync()
        {
            const string sendCommand = "{RP33?}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            return ushort.Parse(result.TrimEnd().Split(':')[1].Replace("}", ""));
        }
        #endregion


        /// <summary>
        /// 执行命令
        /// </summary>
        /// <param name="command"></param>
        /// <param name="timespan"></param>
        /// <returns></returns>
        public async Task<int> RunFromCommand(string command, int? timespan = null)
        {
            var exeCommand = "{" + command + timespan + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(exeCommand));

            string result = Encoding.ASCII.GetString(returnData);
            var timeSpan = result.TrimEnd().Replace("{", "").Replace("}", "").Replace(command, "");
            return string.IsNullOrEmpty(timeSpan) ? 0 : int.Parse(timeSpan);
        }

        /// <summary>
        /// 读单个参数值
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public string GetSingleParamValue(int id)
        {
            var command = "{RP" + id + "}";
            var returnData = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            return result;
        }

        /// <summary>
        /// 读单个参数值
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<string> GetSingleParamValueAsync(int id)
        {
            var command = "{RP" + id + "}";
            var returnData =await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));

            string result = Encoding.ASCII.GetString(returnData);
            return result.TrimEnd();
        }

        /// <summary>
        /// 设置IP地址
        /// </summary>
        /// <param name="ip"></param>
        /// <param name="subNetMask"></param>
        /// <param name="port"></param>
        /// <returns></returns>
        public async Task SetIpAddressAsync(string ip, string subNetMask, int port)
        {
            var ipSplits = ip.Split('.');
            var subNetMaskSplits = subNetMask.Split('.');
            var list = ipSplits.ToList();
            list.AddRange(subNetMaskSplits);
            list.Add(port.ToString());

            var commandId = 13;
            foreach (var command in list.Select(item => "{WP" + $"{commandId}={item}" + "}"))
            {
                var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
                string result = Encoding.ASCII.GetString(returnData);
                commandId++;
            }

            string saveCommand = "{DF}";
            var returnData1 = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(saveCommand));
            string result1 = Encoding.ASCII.GetString(returnData1);
            saveCommand = "{DG}";
            returnData1 = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(saveCommand));
            result1 = Encoding.ASCII.GetString(returnData1);
        }

        /// <summary>
        /// 设置IP地址
        /// </summary>
        /// <param name="ip"></param>
        /// <param name="subNetMask"></param>
        /// <param name="port"></param>
        public void SetIpAddress(string ip, string subNetMask, int port)
        {
            var ipSplits = ip.Split('.');
            var subNetMaskSplits = subNetMask.Split('.');
            var list = ipSplits.ToList();
            list.AddRange(subNetMaskSplits);
            list.Add(port.ToString());
            var commandId = 13;
            foreach (var result in list.Select(item => "{WP" + $"{commandId}={item}" + "}")
                .Select(command => Encoding.ASCII.GetString(WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(command)))))
            {
                commandId++;
            }

            const string saveCommand = "{DG}";
            var result1 = WaitClient.SendThenReturn(Encoding.ASCII.GetBytes(saveCommand));
        }

        /// <summary>
        /// 获取输入触发参数
        /// </summary>
        /// <param name="i"></param>
        /// <returns></returns>
        /// <exception cref="IndexOutOfRangeException"></exception>
        public async Task<int> GetInputTrigger(int i)
        {
            if (i > 2 || i < 0)
            {
                throw new IndexOutOfRangeException("输入的参数id{i}超出了索引");
            }
            var param = await GetSingleParamValueAsync(40 + i - 1);
            var value1 = param.Replace("{", "");
            value1 = value1.Replace("}", "").Split(':')[1];
            return int.Parse(value1);

        }

        /// <summary>
        /// 设置输入触发参数
        /// </summary>
        /// <param name="id"></param>
        /// <param name="value"></param>
        /// <returns></returns>
        /// <exception cref="IndexOutOfRangeException"></exception>
        public async Task SetInputTrigger(int id, int value)
        {
            if (id > 2 || id < 0)
            {
                throw new IndexOutOfRangeException("输入的参数id{i}超出了索引");
            }
            var commandId = 39 + id;
            var command = "{WP" + $"{commandId}={value}" + "}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(command));
            //const string saveCommand = "{DG}";
            //returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(saveCommand));
        }

        /// <summary>
        /// 将所有参数存储至非易失内存中
        /// </summary>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public async Task SaveAllSetAsync()
        {
            string sendCommand = "{DF}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            if (result.TrimEnd() != sendCommand.TrimEnd())
            {
                throw new Exception("FFFeeder响应不正确");
            }
        }

        /// <summary>
        /// 将全局参数存储至非易失内存中
        /// </summary>
        /// <returns></returns>
        /// <exception cref="Exception"></exception>
        public async Task SaveGlobalSetAsync()
        {
            string sendCommand = "{DG}";
            var returnData = await WaitClient.SendThenReturnAsync(Encoding.ASCII.GetBytes(sendCommand));
            string result = Encoding.ASCII.GetString(returnData);
            if (result.TrimEnd() != sendCommand.TrimEnd())
            {
                throw new Exception("FFFeeder响应不正确");
            }
        }
        #endregion

        /// <summary>
        /// 断开连接,释放资源
        /// </summary>
        public void Dispose()
        {
            TcpClient.Close();
            TcpClient.Dispose();
        }

        /// <summary>
        /// 成功连接到服务器
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task ConnectedVoid(ITcpClient client, ConnectedEventArgs e)
        {
            FeederConnectedEvent?.Invoke(this.Id, client,e);
            FeederModel = GetFeederModel();
            //Console.WriteLine($"{client.RemoteIPHost.EndPoint.ToString()}已连接!");
            return EasyTask.CompletedTask;
        }

        /// <summary>
        /// 从服务器断开连接，当连接不成功时不会触发。
        /// </summary>
        /// <param name="client"></param>
        /// <param name="e"></param>
        /// <returns></returns>
        private Task DisconnectedVoid(ITcpClient client, ClosedEventArgs e)
        {
            FeederDisconnectedEvent?.Invoke(this.Id, client,e);
            //Console.WriteLine($"{client.IP}断开连接!");
            return EasyTask.CompletedTask;
        }

        /// <summary>
        /// 获取Feeder型号
        /// </summary>
        /// <returns></returns>
        public FeederModel GetFeederModel()
        {
            try
            {
                string res = GetSingleParamValue(30);
                if (int.TryParse(res,out int model))
                {
                    switch (model)
                    {
                        case 120:
                            return FeederModel.FF120;
                        case 240:
                            return FeederModel.FF240;
                        case 380:
                            return FeederModel.FF380;
                        case 530:
                            return FeederModel.FF530;
                        default:
                            return FeederModel.Unknown;
                    }
                }
                else
                {
                    return FeederModel.Unknown;
                }
            }
            catch (Exception)
            {
                return FeederModel.Unknown;
            }
        }

        /// <summary>
        /// 获取Feeder型号
        /// </summary>
        /// <returns></returns>
        public async Task<FeederModel> GetFeederModelAsync()
        {
            try
            {
                string res =await GetSingleParamValueAsync(30);
                if (int.TryParse(res, out int model))
                {
                    switch (model)
                    {
                        case 120:
                            return FeederModel.FF120;
                        case 240:
                            return FeederModel.FF240;
                        case 380:
                            return FeederModel.FF380;
                        case 530:
                            return FeederModel.FF530;
                        default:
                            return FeederModel.Unknown;
                    }
                }
                else
                {
                    return FeederModel.Unknown;
                }
            }
            catch (Exception)
            {
                return FeederModel.Unknown;
            }
        }
    }
}