using SHJX.Service.Control.Common.Assets;

namespace SHJX.Service.Control.Execute
{
    public class LiquidPipeSwitchOxalate
    {
        #region Fields
        private string _liquidName;
        private static readonly object obj_locker = new();
        private static readonly ILogger logger = LogFactory.BuildLogger(typeof(LiquidPipeSwitchOxalate));
        #endregion

        private LiquidPipeSwitchOxalate() { }

        public static LiquidPipeSwitchOxalate StartNew
        {
            get
            {
                lock (obj_locker)
                {
                    return new();
                }
            }
        }

       
        /// <summary>
        /// 是否原点
        /// </summary>
        public bool IsArriveEndPointOxalate
        {
            get
            {
                lock (obj_locker)
                {
                    char[] readRes = _liquidName.MotorRead();
                    if (readRes is null or { Length: 0 })
                    {
                        return false;
                    }
                    bool arriveEndPoint = readRes[2].Equals('0');
                    return arriveEndPoint;
                }
            }
        }

        /// <summary>
        /// 设置液体名称
        /// </summary>
        /// <param name="liquidName"></param>
        /// <returns></returns>
        public LiquidPipeSwitchOxalate SetLiquidName(string liquidName)
        {
            _liquidName = liquidName;
            return this;
        }

        /// <summary>
        /// 检查是否在原点
        /// </summary>
        /// <returns></returns>
       
        public LiquidPipeSwitchOxalate CheckWhetherArriveEndPointOxalate(LiquidSwitchPattern pattern = LiquidSwitchPattern.Out)
        {
            bool arriveEndPoint = IsArriveEndPointOxalate;
            if (!arriveEndPoint)
            {
                LiquidMotorGoBackOxalate(pattern);//如果不在原点，则切换为出液模式
            }
            return this;
        }

        public bool LiquidMotorGoBackOxalate(LiquidSwitchPattern pattern)
        {
            try
            {
                if (pattern == LiquidSwitchPattern.In)
                {
                    $"{_liquidName}Switch1".RegisterOpen();
                    Thread.Sleep(200);
                }
                else
                {
                    $"{_liquidName}Switch2".RegisterOpen();
                    Thread.Sleep(200);
                }
                var res = _liquidName.MotorGoBack();
               

                int register = ConfigInstance.GetPortRegister(_liquidName);
                int retryCount = 0;
                for (; ; )
                {
                    Thread.Sleep(5 * 100);//如果返回成功，则休眠两秒再次读取
                    char[] judgeRes = _liquidName.MotorRead();
                    if (judgeRes is null or { Length: 0})
                    {
                        return false;
                    }
                    bool reread = false;
                    reread = judgeRes[register -1].Equals('0');
                    if (reread)
                    {
                        break;
                    }
                    retryCount++;
                    logger.LogInformation($"下发返回原点成功后，再次读取原点信号为false，重发返回原点指令第{retryCount}次");
                    if (pattern == LiquidSwitchPattern.In)
                    {
                        $"{_liquidName}Switch1".RegisterOpen();
                        Thread.Sleep(200);
                    }
                    else
                    {
                        $"{_liquidName}Switch2".RegisterOpen();
                        Thread.Sleep(200);
                    }
                    res = _liquidName.MotorGoBack();
                  
                }
                if (pattern == LiquidSwitchPattern.In)
                {
                    $"{_liquidName}Switch1".RegisterClose();
                    Thread.Sleep(200);
                }
                else
                {
                    $"{_liquidName}Switch2".RegisterClose();
                    Thread.Sleep(200);
                }
                return res;
            }
            catch (Exception ex)
            {
                logger.LogInformation($"Error：液体电机返回原点异常。Exception:{ex}");
                return false;
            }
        }
                   
      

        /// <summary>
        /// 执行液体操作
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
       

       
        public bool ExecuteOxalate(object value)
        {
            bool res = ExecuteOxalate(LiquidSwitchPattern.In, value);

            return res && ExecuteOxalate(LiquidSwitchPattern.Out, value);
        }
        public bool ExecuteOxalate(LiquidSwitchPattern pattern, object value)
        {
            int writeData = pattern switch
            {
                LiquidSwitchPattern.In => -Math.Abs(Convert.ToInt32(value)),
                LiquidSwitchPattern.Out => Math.Abs(Convert.ToInt32(value)),
                _ => throw new ArgumentNullException(nameof(pattern)),
            };
            bool res = false;
            if (pattern == LiquidSwitchPattern.In)
            {
                $"{_liquidName}Switch1".RegisterOpen();
                Thread.Sleep(200);
                res = _liquidName.LiquidMotorMove(writeData);
                logger.LogInformation(_liquidName +"*****"+ writeData.ToString() + "*****移动/吸液命令*****草酸钠");
            }
            else
            {
                $"{_liquidName}Switch2".RegisterOpen();
                Thread.Sleep(200);
                res = _liquidName.MotorGoBack();
                logger.LogInformation(_liquidName + "*****" + writeData.ToString() + "*****回原点/出液命令*****草酸钠");
            }
            if (pattern == LiquidSwitchPattern.In)
            {
                $"{_liquidName}Switch1".RegisterClose();
            }
            else
            {
                $"{_liquidName}Switch2".RegisterClose();
            }
            return res;
        }
    }
}