using Quartz;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using IStation.Calculation;

namespace IStation.Server
{
    /// <summary>
    /// 常规实时分析计划任务
    /// </summary>
    public class GeneralRealAnalyCronJob : IJob
    {
        /// <summary>
        /// 时间步长
        /// </summary>
        public int Frequency { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public Task Execute(IJobExecutionContext context)
        {
            return Task.Run(() =>
            {
                try
                {

                    #region 加载分析测点

                    var monitorList = GeneralRealMonitorPointCacheHelper.Get()
                        .Where(x => x.SourceType == Model.Monitor.eSourceType.Analyse && x.Slot.TimeStep == Frequency).ToList();
                    if (monitorList == null || monitorList.Count < 1)
                    {
                        LogHelper.Error($"常规实时分析计划任务中，频率：{Frequency},未检索到常规实时分析测点信息！");
                        return;
                    }
                    #endregion

                    #region 遍历分析

                    foreach (var monitor in monitorList)
                    {

                        #region 数据验证

                        if (string.IsNullOrEmpty(monitor.SourceParas))
                        {
                            LogHelper.Error($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID} 未配置分析参数！");
                            continue;
                        }
                        var analyModel = Model.Monitor.AnalyseParameters.ToModel(monitor.SourceParas);
                        if (analyModel == null)
                        {
                            LogHelper.Error($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID} 分析参数配置错误！");
                            continue;
                        }
                        if (string.IsNullOrEmpty(analyModel.FormulaType))
                        {
                            LogHelper.Error($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID} 未配置公式类型！");
                            continue;
                        }
                        if (string.IsNullOrEmpty(analyModel.FormulaParas))
                        {
                            LogHelper.Error($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID}，未配置公式参数！");
                            continue;
                        }
                        var signal = new Service.Signal().GetFirstExSignalTypeByMonitorPointID(monitor.CorpID, monitor.ID);
                        if (signal == null)
                        {
                            LogHelper.Error($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID} 未检索到信号信息！");
                            continue;
                        }

                        #endregion

                        #region 委托

                        var getMonitorPoint = new Func<long, Model.MonitorPoint>(x => {
                           return GeneralRealMonitorPointCacheHelper.Get().Find(t => t.CorpID == monitor.CorpID && t.ID == x);
                        });
                        var getSignal = new Func<long, Model.Signal_SignalType>(x => {
                            return new Service.Signal().GetFirstExSignalTypeByMonitorPointID(monitor.CorpID, x);
                        });
                        var getLastRecord = new Func<long,long,Model.MonitorBasicRecord>((x,y) => {
                            return new Service.MonitorRealRecord().GetLastNormalRecord(monitor.CorpID,x,y);
                        });
                        var getCurrentLastRecord = new Func<Model.MonitorBasicRecord>(() => {
                            return new Service.MonitorRealRecord().GetLastNormalRecord(monitor.CorpID, monitor.ID,signal.ID);
                        });
                        double srcValue = 0;

                        #endregion

                        switch (analyModel.FormulaType)
                        {
                            case Model.Monitor.FormulaType.Calculation_SingleMapping:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuSingleMapping(analyModel.FormulaParas, getMonitorPoint,getSignal, getLastRecord,out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_CompareMapping:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuCompareMapping(analyModel.FormulaParas, getMonitorPoint, getSignal, getLastRecord, out string msg); 
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_RangeMapping:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuRangeMapping(analyModel.FormulaParas, getMonitorPoint, getSignal, getLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_OnceRatio:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuOnceRatio(analyModel.FormulaParas, getMonitorPoint, getSignal, getLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_TwiceRatio:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuTwiceRatio(analyModel.FormulaParas, getMonitorPoint, getSignal, getLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_RunStatus:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuRunStatus(analyModel.FormulaParas, getMonitorPoint, getSignal, getLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_Sum:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuSum(analyModel.FormulaParas, getMonitorPoint, getSignal, getLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_Diff:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuDiff(analyModel.FormulaParas, getMonitorPoint, getSignal, getLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_NumericAccumulate:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuNumberAccumulate
                                        (analyModel.FormulaParas, getMonitorPoint, getSignal,monitor.Slot.TimeStep, getLastRecord,getCurrentLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_EnumAccumulate:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuEnumAccumulate
                                        (analyModel.FormulaParas, getMonitorPoint, getSignal,monitor.Slot.TimeStep, getLastRecord,getCurrentLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_E:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuE(analyModel.FormulaParas, getMonitorPoint, getSignal, getLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_WP:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuWP(analyModel.FormulaParas, getMonitorPoint, getSignal, getLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            case Model.Monitor.FormulaType.Calculation_UWP:
                                {
                                    srcValue = MonitorFormulaCalcuHelper.CalcuUWP(analyModel.FormulaParas, getMonitorPoint, getSignal, getLastRecord, out string msg);
                                    if (!string.IsNullOrEmpty(msg))
                                    {
                                        LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID},{msg}！");
                                        continue;
                                    }
                                }
                                break;
                            default:
                                {
                                    LogHelper.Error($"常规实时分析计划任务中,分析方法：{analyModel.FormulaType} 暂不支持！");
                                    continue;
                                }
                        }

                        var dataStatus = new List<string>();
                        var dataValue = MonitorHandleHelper.Handle(monitor, signal, getCurrentLastRecord, DateTime.Now, srcValue.ToString(), dataStatus);
                        var analyRecord = MonitorHandleHelper.BuildLastRecord(monitor, signal, DateTime.Now, srcValue.ToString(), DateTime.Now, dataValue, dataStatus);
                        var result = new Service.MonitorRealRecord().InsertLastRecord(analyRecord as Model.MonitorRealRecordPure);
                        if (result)
                        {
                            result = new RabbitMqExChangeHelper().Push(ConfigHelper.RunExchangeName, new List<Model.MonitorBasicRecord>() { analyRecord });
                            if (!result)
                            {
                                LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID} 数据分析记录推入运行监测通道失败！");
                                break;
                            }
                            LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID} 数据分析完成！");
                        }
                        else
                        {
                            LogHelper.Info($"常规实时分析计划任务中，客户标识：{monitor.CorpID},测点标识：{monitor.ID} 数据分析记录保存失败！");
                            break;
                        }

                    }

                    #endregion

                }
                catch (Exception ex)
                {
                    LogHelper.Error("常规实时分析计划任务中，执行出错", ex);
                    var e = new JobExecutionException(ex);
                    throw e;
                }

            });


        }

    }
}