using SHJX.Service.Control.Common.Assets;
using SHJX.Service.Control.Execute.TitrationController;
using shjxCamera;
namespace SHJX.Service.Control.Service
{
    public class ManualService : IManualService
    {
        private static readonly ILogger logger = LogFactory.BuildLogger(typeof(ManualService));

        #region Field
        private readonly IEventAggregator _ea;
        private readonly IDataManager _dataManager;
        private readonly ReadConfigUtil _readConfig;
        public readonly static List<double> GraberValues = new();
        public readonly static List<double> GraberValues2 = new();
        #endregion

        #region Property
        public Dictionary<string, string> ManualTabItems => _readConfig.GetManualTabItem;
        public double DissolveTemperatureDefaultValue => _readConfig.DissolveTemperatureValue;
        public double TitrationTemperatureDefaultValue => _readConfig.TitrationTemperatureValue;
        #endregion

        public ManualService(IEventAggregator ea, IDataManager dataManager, ReadConfigUtil readConfig)
        {
            _ea = ea;
            _dataManager = dataManager;
            _readConfig = readConfig;
            Messager<object>.Register("GraberColorValue", GetGraberValue);
            Messager<object>.Register("TitrationStart", ExecuteTitrationStart);
            Messager<object>.Register("TitrationStop", ExecuteTitrationStop);
            Messager<TitrationValueArgs>.Register("TitrationValueChange", ExecuteTitrationValueChange);

            Messager<object>.Register("GraberColorValue2", GetGraber2Value);
            Messager<object>.Register("TitrationStart2", ExecuteTitration2Start);
            Messager<object>.Register("TitrationStop2", ExecuteTitration2Stop);
            Messager<Titration2ValueArgs>.Register("Titration2ValueChange", ExecuteTitration2ValueChange);
        }

        /// <summary>
        /// 获取数据
        /// </summary>
        /// <param name="value"></param>
        public void GetGraberValue(object value)
        {
            GraberValues.Add(Convert.ToDouble(value));
            _ea.GetEvent<GraberValueEvent>().Publish(GraberValues);
            _ea.GetEvent<TitrationStatusEvent>().Publish(true);
        }
        /// <summary>
        /// 获取数据2
        /// </summary>
        /// <param name="value"></param>
        public void GetGraber2Value(object value)
        {
            GraberValues2.Add(Convert.ToDouble(value));
            _ea.GetEvent<Graber2ValueEvent>().Publish(GraberValues2);
            _ea.GetEvent<Titration2StatusEvent>().Publish(true);
        }
        /// <summary>
        /// 滴定开始
        /// </summary>
        /// <param name="value"></param>
        public void ExecuteTitrationStart(object value)
        {
            try
            {
                GraberValues.Clear();
                _ea.GetEvent<TitrationStatusEvent>().Publish(true);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }
        /// <summary>
        /// 滴定2开始
        /// </summary>
        /// <param name="value"></param>
        public void ExecuteTitration2Start(object value)
        {
            try
            {
                GraberValues.Clear();
                _ea.GetEvent<Titration2StatusEvent>().Publish(true);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 滴定结束
        /// </summary>
        /// <param name="value"></param>
        public void ExecuteTitrationStop(object value)
        {
            try
            {
                GraberValues.Clear();
                _ea.GetEvent<TitrationStatusEvent>().Publish(false);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }
        /// <summary>
        /// 滴定2结束
        /// </summary>
        /// <param name="value"></param>
        public void ExecuteTitration2Stop(object value)
        {
            try
            {
                GraberValues2.Clear();
                _ea.GetEvent<Titration2StatusEvent>().Publish(false);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        /// <summary>
        /// 滴定改变
        /// </summary>
        public void ExecuteTitrationValueChange(TitrationValueArgs arg)
        {
            _ea.GetEvent<TitrationValueEvent>().Publish(arg);
        }
        /// <summary>
        /// 滴定2改变
        /// </summary>
        public void ExecuteTitration2ValueChange(Titration2ValueArgs arg)
        {
            _ea.GetEvent<Titration2ValueEvent>().Publish(arg);
        }

        public List<T> GetData<T>() where T : class => _dataManager.Query<T>().ToList();

        public bool UpdateData<T>(T t) where T : class => _dataManager.Update(t) > 0;
        public bool UpdateAreaAllData(EquipmentArea name)
        {
            DetailState flag = DetailState.Init;
            int flag2 = 1;
            if (!name.Enable)
            {
                flag = DetailState.Doing;
                flag2 = 0;
            }
            _dataManager.Update<SampleDetail>().Where(it => it.NodeName.Equals(name.PointName)).SetValues(it => it.TaskStatus.Set(flag) && it.DetailInfo.Set("")).Execute();
            _dataManager.Update<PositionHotlist>().Where(it => it.PositionName.Equals(name.PointName)).SetValues(it => it.CurrentOccupy.Set(string.Empty) && it.Enable.Set(flag2)).Execute();
            List<EquipmentArea> names = new List<EquipmentArea>();
            names.Add(name);
            _ea.GetEvent<UpdateSampleDetailNullEvent>().Publish(names);
            return true;
        }

        public async Task<bool> ManualWriteRegisterAsync(string name, double value)
        {
            return await Task.Factory.StartNew(() =>
            {
                bool res = ExecuteCommand.RegisterExecute(EquipmentNames.Timer, 1); //开启计时器
                return res && ExecuteCommand.RegisterExecute(name, value); //写入
            });
        }

        public async Task<bool> ManualWriteMoveToMotorAsync(string name, double value, MotorManualMoveType type)
        {
            return await Task.Factory.StartNew(() =>
            {
                MotorConvert convert = _dataManager.Query<MotorConvert>().ToList()?.FirstOrDefault(item => item.MotorName.Equals(name));
                if (convert is null)
                {
                    return false;
                }
                //if (value > 1000 && name.In(EquipmentNames.AxisX, EquipmentNames.AxisY)) //这段代码是xy移动距离大于1000前要看z是否回到原点
                //{
                //    char[] judgeRes = EquipmentNames.AxisZ.MotorRead();
                //    if (judgeRes is null or { Length: 0 })
                //    {
                //        return false;
                //    }
                //    if (!judgeRes[3 - 1].Equals('0'))
                //    {
                //        EquipmentNames.AxisZ.MotorGoBack();
                //    }
                //}
                bool res = name.LiquidMotorMove(Convert.ToInt32(Math.Round(value * convert.ConvertRatio)));
                MotorMoveStatus status = _dataManager.Query<MotorMoveStatus>().ToList()?.FirstOrDefault(item => item.MotorName.Equals(name));
                if (status is null)
                {
                    return res;
                }
                if (res)
                {
                    switch (type)
                    {
                        case MotorManualMoveType.Forward:
                            status.CurrentPosition += Math.Abs(value);
                            break;
                        case MotorManualMoveType.Inversion:
                            status.CurrentPosition -= Math.Abs(value);
                            if (status.CurrentPosition < 0)
                            {
                                status.CurrentPosition = 0;
                            }
                            break;
                    }
                    _dataManager.Update(status);
                }
                return res;
            });
        }
        public async Task<bool> ManualWriteMoveToDMotor(string name, double value, MotorManualMoveType type)
        {
            return await Task.Factory.StartNew(() =>
            {
                MotorConvert convert = _dataManager.Query<MotorConvert>().ToList()?.FirstOrDefault(item => item.MotorName.Equals(name));
                if (convert is null)
                {
                    return false;
                }
                MotorMoveStatus status = _dataManager.Query<MotorMoveStatus>().ToList()?.FirstOrDefault(item => item.MotorName.Equals(name));
                if (status is null)
                {
                    return false;
                }
                bool res = name.LiquidMotorMove(Convert.ToInt32(Math.Round(-1*(Math.Abs(value) - status.CurrentPosition ) * convert.ConvertRatio)));
                if (res)
                {
                    switch (type)
                    {
                        case MotorManualMoveType.Forward:
                            status.CurrentPosition = Math.Abs(value);
                            break;
                    }
                    _dataManager.Update(status);
                }
                return res;
            });
        }

        public async Task<bool> MotorGoBackAsync(string name)
        {
            return await Task.Factory.StartNew(() =>
            {
                return ExecuteCommand.MotorGoBackExecute(name);
            });
        }

        public bool MotorStop(string name) => name.MotorStop();

        public async Task<bool> UpdateSpeedAsync(string name)
        {
            return await Task.Factory.StartNew(() =>
            {
                MotorSpeed speed = _dataManager.Query<MotorSpeed>().Where(it => it.DetailName.Equals(name)).First();
                bool res = speed.SystemName.WriteSpeed(speed.Speed);
                res = res && speed.SystemName.WriteAcSpeed(speed.AcSpeed);
                res = res && speed.SystemName.WriteDeSpeed(speed.DeSpeed);
                return res;
            });
        }

        public bool ManualControlRegister(string typeName, RegisterExecuteType type)
        {
            bool res = type switch
            {
                RegisterExecuteType.Open => typeName.RegisterOpen(),
                RegisterExecuteType.Close => typeName.RegisterClose(),
                _ => throw new ArgumentNullException(typeName),
            };
            return res;
        }

        public bool ManualSettingPID(string type, object value)
        {
            bool res = type.ToLower() switch
            {
                "ratio" => EquipmentNames.DissolveHeating.WriteRatio(value),
                "integral" => EquipmentNames.DissolveHeating.WriteIntegral(value),
                "differential" => EquipmentNames.DissolveHeating.WriteDifferential(value),
                "integraldeafult" => EquipmentNames.DissolveHeating.WriteIntegralDeafult(value),
                _ => throw new ArgumentException("未找到对应PID项定义")
            };
            return res;
        }

        public bool ManualSettingTemp(object value)
        {
            return EquipmentNames.DissolveHeating.WriteTemperature(value);
        }

        public async Task<bool> ManualDirectOutLiquidAsync(string type, object value)
        {
            return await Task.Factory.StartNew(() =>
            {
                return type.LiquidMotorMove(Convert.ToInt32(Math.Round(Convert.ToDouble(value))));
            });
        }

        //public static async Task<bool> ManualLiquidExecuteStatic(string pumpName, LiquidSwitchPattern pattern, object value)
        //{
        //    return await Task.Factory.StartNew(() =>
        //    {
        //        return LiquidPipeSwitch.StartNew.SetLiquidName(pumpName).Execute(pattern, value);
        //    });
        //}
        public async Task<bool> ManualLiquidExecute(string pumpName, LiquidSwitchPattern pattern, object value)
        {
            return await Task.Factory.StartNew(() =>
            {
                return LiquidPipeSwitch.StartNew.SetLiquidName(pumpName).Execute(pattern, value);
            });
        }
        public async Task<bool> ManualLiquidExecuteOxalate(string pumpName, LiquidSwitchPattern pattern, object value)
        {
            return await Task.Factory.StartNew(() =>
            {
                return LiquidPipeSwitchOxalate.StartNew.SetLiquidName(pumpName).ExecuteOxalate(pattern, value);
            });
        }

        public LiquidAmount GetOnceDropLiquidAmount()
        {
            LiquidAmount liquid = _dataManager.Query<LiquidAmount>().Where(it => it.LiquidName.Equals(EquipmentNames.Titration1PotassiumPermanganate)).First();
            return liquid;
        }

        public void ManualExecuteTitration(TitrationArg arg)
        {
            double amount = 0.0;
            TitrationExecute.Start(arg, ref amount);
        }
        public void ManualExecuteTitrationStop()
        {
            TitrationExecute.Running = false;
            
        }
        public void ManualExecuteExplosion(int MaxCameraRange)
        {
            ColorDataGraber _graber = Globals.Graber;
            CameraValue explosion = _dataManager.Query<CameraValue>().First();
            _graber.PresetLightParammanual(explosion, MaxCameraRange);
        }

        public void ManualExecuteTitration2(Titration2Arg arg)
        {
            double amount = 0.0;
            Titration2Execute.Start(arg, ref amount);
        }
        public void ManualExecuteTitration2Stop()
        {
            Titration2Execute.Running = false;
        }
        public void ManualExecuteExplosion2(int MaxCameraRange)
        {
            ColorData2Graber _graber = Globals.Graber2;
            Camera2Value explosion= _dataManager.Query<Camera2Value>().First();
            _graber.PresetLightParammanual(explosion, MaxCameraRange);
        }

        public void ManualcheckParams2()
        {
            ColorData2Graber _graber = Globals.Graber2;
            _graber.ShowParammanual();
        }

        public void ManualcheckParams()
        {
            ColorDataGraber _graber = Globals.Graber;
            _graber.ShowParammanual();
        }
        /// <summary>
        /// 计算k值
        /// </summary>
        /// <returns></returns>
        public double CalculationKValue()
        {
            List<EquipmentTask> tasks = _dataManager.Query<EquipmentTask>().Where(it => it.TaskType.Equals(TaskTypeName.CALIBRATION_ZH)).With(a => a.WaveKey, b => b.WaveKey, _dataManager.Query<EquipmentTask>().Where(it => it.TaskType.Equals(TaskTypeName.CALIBRATION_ZH) && it.Status.Equals(TaskState.Finished)).OrderBy(it => it.CreateTime, OrderPattern.Desc).Take(1), WithPattern.Equals).ToList();
            if (!tasks.Any())
            {
                return 0;
            }
            double volumeSum = 0.0;
            foreach (EquipmentTask task in tasks)
            {
                volumeSum += task.Amount;
            }
            if (volumeSum.Equals(0))
            {
                return 0;
            }
            double avgRes = volumeSum / tasks.Count;
            double returnResult = 10 / avgRes;
            return Math.Round(returnResult,3);
        }
        public Task<bool> ElectricDropper(string EpType, RegisterExecuteType type)
        {
            bool res = type switch
            {
                RegisterExecuteType.Open => DropperForward(EpType),
                RegisterExecuteType.Close => DropperInversion(EpType),
                RegisterExecuteType.Point => DropperPoint(EpType),
                _ => throw new ArgumentOutOfRangeException(nameof(type)),
            };
            return Task.FromResult(res);
            
        }
        public Task<bool> ElectricDropperFind(string EpType, RegisterExecuteType type)
        {
            bool res = type switch
            {
                RegisterExecuteType.Open => DropperForward(EpType),
                RegisterExecuteType.Close => DropperInversion(EpType),
                _ => throw new ArgumentOutOfRangeException(nameof(type)),
            };
            return Task.FromResult(res);
        }

        private static bool DropperForward(string elementName)
        {
            char[] readData2 = $"{elementName}Dropper".MotorRead();
            if (readData2 is null or not { Length: 8 })
            {
                return false;
            }
            if (readData2[5 - 1].Equals('0'))
            {

                $"{elementName}DropperForward".RegisterOpen();
                Thread.Sleep(200);
                $"{elementName}DropperInversion".RegisterOpen();
                bool res = true;
                do
                {
                    Thread.Sleep(200);
                    char[] readData = $"{elementName}Dropper".MotorRead();
                    if (readData is null or not { Length: 8 })
                    {
                        continue;
                    }
                    res = readData[6 - 1].Equals('0');

                } while (!res);
                $"{elementName}DropperInversion".RegisterClose();
                Thread.Sleep(200);
                $"{elementName}DropperForward".RegisterClose();
                return true;
            }
            else
                return false;
        }

        public static bool DropperInversion(string elementName)
        {
            char[] readData2 = $"{elementName}Dropper".MotorRead();
            if (readData2 is null or not { Length: 8})
            {
                return false;
            }
            if (readData2[6 - 1].Equals('0'))
            {
                bool res = $"{elementName}DropperInversion".RegisterOpen();
                do
                {
                    Thread.Sleep(200);
                    char[] readData = $"{elementName}Dropper".MotorRead();
                    if (readData is null or not { Length: 8 })
                    {
                        continue;
                    }
                    res = readData[5 - 1].Equals('0');
                } while (!res);
                $"{elementName}DropperInversion".RegisterClose();
                return res;
            }
            else
                return false;
        }

        public static bool DropperPoint(string elementName)
        {
            char[] readData2 = $"{elementName}Dropper".MotorRead();
            if (readData2 is null or not { Length: 8 })
            {
                return false;
            }
            bool res = $"{elementName}DropperInversion".RegisterOpen();
            do
            {
                Thread.Sleep(200);
                char[] readData = $"{elementName}Dropper".MotorRead();
                if (readData is null or not { Length: 8 })
                {
                    continue;
                }
                res = readData[5 - 1].Equals('0');
            } while (!res);
            $"{elementName}DropperInversion".RegisterClose();
            return res;
        }

    }
}