using SHJX.Service.Control.Extends;
using SHJX.Service.Model.Dao;

namespace SHJX.Service.Control.Schedules
{
    [EnableScheduling]
    public class ElementSchedule : IScheduler
    {
        private static readonly ILogger logger = LogFactory.BuildLogger(typeof(ElementSchedule));
        private static IEventAggregator _ea;
        private static IDataManager _dataManager;

        public ElementSchedule(IDataManager dataManager, IEventAggregator ea)
        {
            _ea = ea;
            _dataManager = dataManager;
        }

        [Scheduled("ReadCurrentTemperatureFromDissolve", 1000)]
        public void ReadCurrentTemperatureFromDissolve()
        {
            Dictionary<string, double> obj = EquipmentNames.DissolveHeating.HeatRead();
            if (obj is null or { Count: 0 })
            {
                return;
            }
            ReadTemperatureArgs args = new()
            {
                SettingTemperature = obj["sv"],
                CurrentTemperature = obj["pv"]
            };
            _ea.GetEvent<DissolveCurrentHeatingValueEvent>().Publish(args);
        }

        [Scheduled("ReadCurrentHumiture", 10000)]
        public void ReadCurrentHumiture()
        {
            //ushort[] res = PortExecute.HumitureRead();
            //if (res is null or { Length: 0 })
            //{
            //    return;
            //}
            //double temp = res[0] / 10.0;
            //double humidi = res[1] / 10.0;
            //_ea.GetEvent<NoticeHumitureEvent>().Publish((Temperature: temp, Humidity: humidi));
        }


        [Scheduled("ReadCurrentTemperatureFromTitration", 1000)]
        public void ReadCurrentTemperatureFromTitration()
        {
            Dictionary<string, double> obj = EquipmentNames.TitrationHeating.HeatRead();
            if (obj is null or { Count: 0 })
            {
                return;
            }
            ReadTemperatureArgs args = new()
            {
                SettingTemperature = obj["sv"],
                CurrentTemperature = obj["pv"]
            };
            _ea.GetEvent<TitrationCurrentHeatingValueEvent>().Publish(args);
        }

        [Scheduled("CalculateKValueByWaveKey", 1000)]
        public void CalculateKValueByWaveKey()
        {
            //先查找WaveKey值
            Wavekey key = (from wavekey in _dataManager.Query<Wavekey>().ToList() orderby wavekey.WaveKey descending select wavekey).FirstOrDefault();
            double k = CalculationResult.CalculateType(key.WaveKey, TaskTypeName.CALIBRATION_ZH, (arg) => 10 / arg);
            _ea.GetEvent<NoticeKValueEvent>().Publish(k);
        }

        [Scheduled("DissolveTimeChange", 1000)]
        public void DissolveTimeChange()
        {
            try
            {
                List<DissolveDate> dissolves = _dataManager.Query<DissolveDate>().ToList();
                if (!dissolves.Any())
                {
                    return;
                }
                List<HeatingChangeArgs> heatings = new();
                ExecuteTime executeTime = _dataManager.Query<ExecuteTime>().Where(it => it.TypeName.Equals(ExecuteTimeName.DISSOLVE_TIME)).First();
                foreach (DissolveDate dissolve in dissolves)
                {
                    double timeDifference = 0.0;
                    HeatingChangeArgs heatingArg = new() { Name = dissolve.PositionName };
                    if (dissolve.Start)
                    {
                        heatingArg.Dispaly = dissolve.Start;
                        DateTime lastTime = dissolve.LastTryTime;
                        double time = ((DateTime.Now.Hour - lastTime.Hour) * 60.0 * 60.0) + ((DateTime.Now.Minute - lastTime.Minute) * 60.0) + (DateTime.Now.Second - lastTime.Second);
                        timeDifference = time / (executeTime.Value * 60.0);
                    };
                    heatingArg.Progress = timeDifference;
                    heatings.Add(heatingArg);
                }
                _ea.GetEvent<UpdateDissolveElementEvent>().Publish(heatings);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }

        [Scheduled("ChangePositionElementDisplay", 1000)]
        public void ChangePositionElementDisplay()
        {
            try
            {
                List<PositionHotlist> hotlists = _dataManager.Query<PositionHotlist>().ToList();
                if (!hotlists.Any())
                {
                    return;
                }
                List<ElementArgs> elements = new();
                foreach (PositionHotlist item in hotlists)
                {
                    ElementArgs args = new()
                    {
                        Name = item.PositionName,
                        Current = item.CurrentOccupy,
                        Enable = item.Enable
                    };
                    elements.Add(args);
                }
                _ea.GetEvent<UpdateElementEvent>().Publish(elements);
            }
            catch (Exception ex)
            {
                logger.LogError(ex.ToString());
            }
        }
    }
}