using IStation.Untity;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace IStation.Calculation
{
    /// <summary>
    /// 监测处理辅助类
    /// </summary>
    public static class MonitorHandleHelper
    {
        /// <summary>
        /// 处理
        /// </summary>
        /// <param name="monitor">测点</param>
        /// <param name="signal">信号</param>
        /// <param name="receiveRecord">接收记录</param>
        /// <param name="lastRecord">最后一次记录</param>
        /// <param name="dataTime">数据时间</param>
        /// <returns>为null则不需要后续处理</returns>
        public static Model.MonitorBasicRecord Handle
            (
                Model.MonitorPoint monitor,
                Model.Signal_SignalType signal,
                Model.MonitorDataDockingReceiveRecord receiveRecord,
                Model.MonitorBasicRecord lastRecord,
                DateTime dataTime
            )
        {
            Model.MonitorBasicRecord record = null;//监测记录           
            var dataStatus = receiveRecord.DataStatus;//数据状态
            if (dataStatus == null)
                dataStatus = new List<string>();
            var dataValue = receiveRecord.SrcValue;//数据值

            #region 实时记录 和 最后一次记录对比，判断是否完全一样，并根据条件判断是否需要补充点

            if (monitor.CronType == Model.Monitor.eCronType.Real)
            {
                if (lastRecord != null)
                {
                    if (lastRecord.SrcTime == receiveRecord.SrcTime)
                    {
                        //相同时间给出了相同值
                        if (lastRecord.SrcValue == receiveRecord.SrcValue)
                        {
                            var real_slot = Model.Monitor.RealSlot.ToModel(monitor.CronParas);
                            if (real_slot == null)
                            {
                                real_slot = new Model.Monitor.RealSlot();
                            }
                            if (!real_slot.UpdateWhenChanged)
                            {
                                return record;
                            }
                            dataStatus.Add(MonitorRecord.Status_Supplement);
                        }
                    }
                }
            }

            #endregion

            #region 通过信号类型的值类型和信号的数据类型进行相关的换算

            switch (signal.SignalType.ValueType)
            {
                case Model.Monitor.eValueType.Numeric:
                    {
                        //数值验证
                        if (!double.TryParse(dataValue, out double dataValueNumeric))
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换
                        if (signal.ConvertParas != null)
                        {
                            dataValueNumeric = signal.ConvertParas.Convert(dataValueNumeric, out bool succed);
                            if (!succed)
                            {
                                dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                            }
                        }

                        //数据修正
                        if (signal.CorrectParas != null)
                        {
                            dataValueNumeric = signal.CorrectParas.Correct(dataValueNumeric);
                        }

                        //类型特殊情况处理 （累积的清零和初始值）
                        switch (signal.DataType)
                        {
                            case Model.Monitor.eDataType.Instant://瞬时
                                {

                                }
                                break;
                            case Model.Monitor.eDataType.Accumulate://累积
                                {
                                    var dataTypeModel = Model.Monitor.AccumulateParameters.ToModel(signal.DataParas);
                                    if (dataTypeModel != null)
                                    {
                                        if (lastRecord == null)
                                        {
                                            if (dataTypeModel.InitialValue != null)
                                            {
                                                dataValueNumeric += dataTypeModel.InitialValue.Value;
                                            }
                                        }
                                        else
                                        {
                                            if (dataTypeModel.ClearValue != null)
                                            {

                                                if (dataValueNumeric >= dataTypeModel.ClearValue.Value - dataTypeModel.ClearErrorValue && dataValueNumeric <= dataTypeModel.ClearValue.Value + dataTypeModel.ClearErrorValue)
                                                {
                                                    dataValueNumeric += double.Parse(lastRecord.DataValue);
                                                }
                                            }
                                        }
                                    }
                                }
                                break;
                        }

                        //数据过滤
                        if (signal.FilterParas != null)
                        {
                            double? lastDataValue = null;
                            if (lastRecord != null)
                            {
                                if (double.TryParse(lastRecord.DataValue, out double dataValueTemp))
                                {
                                    lastDataValue = dataValueTemp;
                                }
                            }
                            if (!signal.FilterParas.Filter(dataValueNumeric, lastDataValue))
                            {
                                dataStatus.Add(MonitorRecord.Status_FilterFailed);
                            }
                        }

                        //保留小数位数
                        if (signal.SignalType.DecimalPlaces != null)
                        {
                            dataValueNumeric = Math.Round(dataValueNumeric, signal.SignalType.DecimalPlaces.Value);
                        }

                        dataValue = dataValueNumeric.ToString();
                    }
                    break;
                case Model.Monitor.eValueType.Enum:
                    {
                        //数值转换
                        if (!double.TryParse(dataValue, out double dataValueEnum))
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换
                        if (signal.ConvertParas != null)
                        {
                            dataValueEnum = signal.ConvertParas.Convert(dataValueEnum, out bool succed);
                            if (!succed)
                            {
                                dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                            }
                        }

                        //数据修正
                        if (signal.CorrectParas != null)
                        {
                            dataValueEnum = signal.CorrectParas.Correct(dataValueEnum);
                        }

                        //数据过滤
                        if (signal.FilterParas != null)
                        {
                            double? dataValue_last = null;
                            if (lastRecord != null)
                            {
                                if (double.TryParse(lastRecord.DataValue, out double dataValueTemp))
                                {
                                    dataValue_last = dataValueTemp;
                                }
                            }
                            if (!signal.FilterParas.Filter(dataValueEnum, dataValue_last))
                            {
                                dataStatus.Add(MonitorRecord.Status_FilterFailed);
                            }
                        }

                        //保留小数位数
                        if (signal.SignalType.DecimalPlaces != null)
                        {
                            dataValueEnum = Math.Round(dataValueEnum, signal.SignalType.DecimalPlaces.Value);
                        }

                        dataValue = dataValueEnum.ToString();
                    }
                    break;
                case Model.Monitor.eValueType.Array:
                    {
                        //数据格式验证
                        var dataValueArray = DoubleListHelper.ToList(dataValue);
                        if (dataValueArray == null || dataValueArray.Count < 1)
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换、修正、保留小数位数
                        var dataValueArrayNew = new List<double>();
                        foreach (var dataValueNumeric in dataValueArray)
                        {
                            var dataValueNumericNew = dataValueNumeric;

                            //数据转换
                            if (signal.ConvertParas != null)
                            {
                                dataValueNumericNew = signal.ConvertParas.Convert(dataValueNumericNew, out bool succed);
                                if (!succed)
                                {
                                    dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                                }
                            }

                            //数值修正
                            if (signal.CorrectParas != null)
                            {
                                dataValueNumericNew = signal.CorrectParas.Correct(dataValueNumericNew);
                            }

                            //保留小数位数
                            if (signal.SignalType.DecimalPlaces != null)
                            {
                                dataValueNumericNew = Math.Round(dataValueNumericNew, signal.SignalType.DecimalPlaces.Value);
                            }

                            dataValueArrayNew.Add(dataValueNumericNew);
                        }
                        dataValue = DoubleListHelper.ToString(dataValueArrayNew);
                    }
                    break;
                case Model.Monitor.eValueType.Integration:
                    {

                    }
                    break;
                default: break;
            }

            #endregion

            #region 监测记录生成

            switch (monitor.CronType)
            {
                case Model.Monitor.eCronType.Real:
                    {
                        var realRecord = new Model.MonitorRealRecordPure();
                        realRecord.CorpID = monitor.CorpID;
                        realRecord.MonitorPointID = monitor.ID;
                        realRecord.SignalID = signal.ID;
                        realRecord.RecordType = receiveRecord.RecordType;
                        realRecord.SrcTime = receiveRecord.SrcTime;
                        realRecord.SrcValue = receiveRecord.SrcValue;
                        realRecord.DataTime = dataTime;
                        realRecord.DataValue = dataValue;
                        realRecord.DataStatus = dataStatus;
                        record = realRecord;
                    }
                    break;
                case Model.Monitor.eCronType.EachHour:
                    {
                        var hourRecord = new Model.MonitorHourRecordPure();
                        hourRecord.CorpID = monitor.CorpID;
                        hourRecord.MonitorPointID = monitor.ID;
                        hourRecord.SignalID = signal.ID;
                        hourRecord.RecordType = receiveRecord.RecordType;
                        hourRecord.SrcTime = receiveRecord.SrcTime;
                        hourRecord.SrcValue = receiveRecord.SrcValue;
                        hourRecord.DataDay = dataTime.AddHours(-1).Date;
                        hourRecord.DataHour = dataTime.AddHours(-1).Hour + 1;
                        hourRecord.DataTime = dataTime;
                        hourRecord.DataValue = dataValue;
                        hourRecord.DataStatus = dataStatus;
                        record = hourRecord;
                    }
                    break;
                case Model.Monitor.eCronType.EachDay:
                    {
                        var dayRecord = new Model.MonitorDayRecordPure();
                        dayRecord.CorpID = monitor.CorpID;
                        dayRecord.MonitorPointID = monitor.ID;
                        dayRecord.SignalID = signal.ID;
                        dayRecord.RecordType = receiveRecord.RecordType;
                        dayRecord.SrcTime = receiveRecord.SrcTime;
                        dayRecord.SrcValue = receiveRecord.SrcValue;
                        dayRecord.DataDay = dataTime.AddDays(-1).Date;
                        dayRecord.DataTime = dataTime;
                        dayRecord.DataValue = dataValue;
                        dayRecord.DataStatus = dataStatus;
                        record = dayRecord;
                    }
                    break;
                case Model.Monitor.eCronType.EachWeek:
                    {
                        var weekRecord = new Model.MonitorWeekRecordPure();
                        weekRecord.CorpID = monitor.CorpID;
                        weekRecord.MonitorPointID = monitor.ID;
                        weekRecord.SignalID = signal.ID;
                        weekRecord.RecordType = receiveRecord.RecordType;
                        weekRecord.SrcTime = receiveRecord.SrcTime;
                        weekRecord.SrcValue = receiveRecord.SrcValue;
                        weekRecord.DataTime = dataTime;
                        weekRecord.DataValue = dataValue;
                        weekRecord.DataStatus = dataStatus;
                        var cron_week = Model.Monitor.WeekSlot.ToModel(monitor.CronParas);
                        if (cron_week == null)
                            cron_week = new Model.Monitor.WeekSlot();
                        weekRecord.StartDay = cron_week.GetStartTime(dataTime).Date;
                        weekRecord.EndDay = cron_week.GetEndTime(dataTime).AddDays(-1).Date;
                        record = weekRecord;
                    }
                    break;
                case Model.Monitor.eCronType.EachMonth:
                    {
                        var monthRecord = new Model.MonitorMonthRecordPure();
                        monthRecord.CorpID = monitor.CorpID;
                        monthRecord.MonitorPointID = monitor.ID;
                        monthRecord.SignalID = signal.ID;
                        monthRecord.RecordType = receiveRecord.RecordType;
                        monthRecord.SrcTime = receiveRecord.SrcTime;
                        monthRecord.SrcValue = receiveRecord.SrcValue;
                        monthRecord.DataYear = dataTime.AddMonths(-1).Year;
                        monthRecord.DataMonth = dataTime.AddMonths(-1).Month;
                        monthRecord.DataTime = dataTime;
                        monthRecord.DataValue = dataValue;
                        monthRecord.DataStatus = dataStatus;
                        record = monthRecord;
                    }
                    break;
                case Model.Monitor.eCronType.EachYear:
                    {
                        var yearRecord = new Model.MonitorYearRecordPure();
                        yearRecord.CorpID = monitor.CorpID;
                        yearRecord.MonitorPointID = monitor.ID;
                        yearRecord.SignalID = signal.ID;
                        yearRecord.RecordType = receiveRecord.RecordType;
                        yearRecord.SrcTime = receiveRecord.SrcTime;
                        yearRecord.SrcValue = receiveRecord.SrcValue;
                        yearRecord.DataYear = dataTime.AddYears(-1).Year;
                        yearRecord.DataTime = dataTime;
                        yearRecord.DataValue = dataValue;
                        yearRecord.DataStatus = dataStatus;
                        record = yearRecord;
                    }
                    break;
                default: break;
            }

            #endregion

            return record;

        }

        /// <summary>
        /// 处理历史数据
        /// </summary>
        /// <param name="monitor">测点</param>
        /// <param name="signal">信号</param>
        /// <param name="receiveRecord">接收记录</param>
        /// <param name="dataTime">数据时间</param>
        /// <returns>为null则不需要后续处理</returns>
        public static Model.MonitorBasicRecord HandleHistory
            (
                Model.MonitorPoint monitor,
                Model.Signal_SignalType signal,
                Model.MonitorDataDockingReceiveRecord receiveRecord,
                DateTime dataTime
            )
        {
            Model.MonitorBasicRecord record = null;//监测记录           
            var dataStatus = receiveRecord.DataStatus;//数据状态
            if (dataStatus == null)
                dataStatus = new List<string>();
            var dataValue = receiveRecord.SrcValue;//数据值


            #region 通过信号类型的值类型和信号的数据类型进行相关的换算

            switch (signal.SignalType.ValueType)
            {
                case Model.Monitor.eValueType.Numeric:
                    {
                        //数值验证
                        if (!double.TryParse(dataValue, out double dataValueNumeric))
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换
                        if (signal.ConvertParas != null)
                        {
                            dataValueNumeric = signal.ConvertParas.Convert(dataValueNumeric, out bool succed);
                            if (!succed)
                            {
                                dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                            }
                        }

                        //数据修正
                        if (signal.CorrectParas != null)
                        {
                            dataValueNumeric = signal.CorrectParas.Correct(dataValueNumeric);
                        }


                        //数据过滤
                        if (signal.FilterParas != null)
                        {
                            if (!signal.FilterParas.Filter(dataValueNumeric, null))
                            {
                                dataStatus.Add(MonitorRecord.Status_FilterFailed);
                            }
                        }

                        //保留小数位数
                        if (signal.SignalType.DecimalPlaces != null)
                        {
                            dataValueNumeric = Math.Round(dataValueNumeric, signal.SignalType.DecimalPlaces.Value);
                        }

                        dataValue = dataValueNumeric.ToString();
                    }
                    break;
                case Model.Monitor.eValueType.Enum:
                    {
                        //数值转换
                        if (!double.TryParse(dataValue, out double dataValueEnum))
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换
                        if (signal.ConvertParas != null)
                        {
                            dataValueEnum = signal.ConvertParas.Convert(dataValueEnum, out bool succed);
                            if (!succed)
                            {
                                dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                            }
                        }

                        //数据修正
                        if (signal.CorrectParas != null)
                        {
                            dataValueEnum = signal.CorrectParas.Correct(dataValueEnum);
                        }

                        //数据过滤
                        if (signal.FilterParas != null)
                        {
                            if (!signal.FilterParas.Filter(dataValueEnum, null))
                            {
                                dataStatus.Add(MonitorRecord.Status_FilterFailed);
                            }
                        }

                        //保留小数位数
                        if (signal.SignalType.DecimalPlaces != null)
                        {
                            dataValueEnum = Math.Round(dataValueEnum, signal.SignalType.DecimalPlaces.Value);
                        }

                        dataValue = dataValueEnum.ToString();
                    }
                    break;
                case Model.Monitor.eValueType.Array:
                    {
                        //数据格式验证
                        var dataValueArray = DoubleListHelper.ToList(dataValue);
                        if (dataValueArray == null || dataValueArray.Count < 1)
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换、修正、保留小数位数
                        var dataValueArrayNew = new List<double>();
                        foreach (var dataValueNumeric in dataValueArray)
                        {
                            var dataValueNumericNew = dataValueNumeric;

                            //数据转换
                            if (signal.ConvertParas != null)
                            {
                                dataValueNumericNew = signal.ConvertParas.Convert(dataValueNumericNew, out bool succed);
                                if (!succed)
                                {
                                    dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                                }
                            }

                            //数值修正
                            if (signal.CorrectParas != null)
                            {
                                dataValueNumericNew = signal.CorrectParas.Correct(dataValueNumericNew);
                            }

                            //保留小数位数
                            if (signal.SignalType.DecimalPlaces != null)
                            {
                                dataValueNumericNew = Math.Round(dataValueNumericNew, signal.SignalType.DecimalPlaces.Value);
                            }

                            dataValueArrayNew.Add(dataValueNumericNew);
                        }
                        dataValue = DoubleListHelper.ToString(dataValueArrayNew);
                    }
                    break;
                case Model.Monitor.eValueType.Integration:
                    {

                    }
                    break;
                default: break;
            }

            #endregion

            #region 监测记录生成

            record = BuildMonitorRecord(monitor,signal,receiveRecord.SrcTime,receiveRecord.SrcValue,dataTime,dataValue,dataStatus);

            #endregion

            return record;

        }

        /// <summary>
        /// 处理
        /// </summary>
        /// <param name="monitor">测点</param>
        /// <param name="signal">信号</param>
        /// <param name="lastRecord">最后一次记录</param>
        /// <param name="srcValue">原始值</param>
        /// <param name="dataStatus">数据状态</param>
        /// <returns>为空则不需要后续处理</returns>
        public static string Handle
            (
                Model.MonitorPoint monitor,
                Model.Signal_SignalType signal,
                Model.MonitorBasicRecord lastRecord,
                DateTime srcTime,
                string srcValue,
                List<string> dataStatus
            )
        {
            //数据状态
            if (dataStatus == null)
            {
                dataStatus = new List<string>();
            }
            var dataValue = srcValue;//数据值

            #region 和最后一次记录对比，判断是否完全一样，并根据条件判断是否需要补充点

            if (monitor.CronType == Model.Monitor.eCronType.Real)
            {
                if (lastRecord != null)
                {
                    if (lastRecord.SrcTime == srcTime)
                    {
                        //相同时间给出了相同值
                        if (lastRecord.SrcValue == srcValue)
                        {
                            var real_slot = Model.Monitor.RealSlot.ToModel(monitor.CronParas);
                            if (real_slot == null)
                            {
                                real_slot = new Model.Monitor.RealSlot();
                            }
                            if (!real_slot.UpdateWhenChanged)
                            {
                                return default;
                            }
                            dataStatus.Add(MonitorRecord.Status_Supplement);
                        }
                    }
                }
            }

            #endregion

            #region 通过信号类型的值类型和信号的数据类型进行相关的换算

            switch (signal.SignalType.ValueType)
            {
                case Model.Monitor.eValueType.Numeric:
                    {
                        //数值验证
                        if (!double.TryParse(dataValue, out double dataValueNumeric))
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换
                        if (signal.ConvertParas != null)
                        {
                            dataValueNumeric = signal.ConvertParas.Convert(dataValueNumeric, out bool succed);
                            if (!succed)
                            {
                                dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                            }
                        }

                        //数据修正
                        if (signal.CorrectParas != null)
                        {
                            dataValueNumeric = signal.CorrectParas.Correct(dataValueNumeric);
                        }

                        //类型特殊情况处理 （累积的清零和初始值）
                        switch (signal.DataType)
                        {
                            case Model.Monitor.eDataType.Instant://瞬时
                                {

                                }
                                break;
                            case Model.Monitor.eDataType.Accumulate://累积
                                {
                                    var dataTypeModel = Model.Monitor.AccumulateParameters.ToModel(signal.DataParas);
                                    switch (monitor.SourceType)
                                    {
                                        case Model.Monitor.eSourceType.Docking:
                                            {
                                                if (dataTypeModel != null)
                                                {
                                                    if (lastRecord == null)
                                                    {
                                                        if (dataTypeModel.InitialValue != null)
                                                        {
                                                            dataValueNumeric += dataTypeModel.InitialValue.Value;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (dataTypeModel.ClearValue != null)
                                                        {

                                                            if (dataValueNumeric >= dataTypeModel.ClearValue.Value - dataTypeModel.ClearErrorValue && dataValueNumeric <= dataTypeModel.ClearValue.Value + dataTypeModel.ClearErrorValue)
                                                            {
                                                                dataValueNumeric += double.Parse(lastRecord.DataValue);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            break;
                                        case Model.Monitor.eSourceType.Analyse:
                                            {
                                                if (lastRecord == null)
                                                {
                                                    if (dataTypeModel != null)
                                                    {
                                                        if (dataTypeModel.InitialValue != null)
                                                        {
                                                            dataValueNumeric += dataTypeModel.InitialValue.Value;
                                                        }
                                                    }
                                                }
                                                else
                                                {
                                                    if (double.TryParse(lastRecord.DataValue, out double last_value))
                                                    {
                                                        dataValueNumeric += last_value;
                                                    }
                                                }
                                            }
                                            break;
                                        case Model.Monitor.eSourceType.Input:
                                            {
                                                if (dataTypeModel != null)
                                                {
                                                    if (lastRecord == null)
                                                    {
                                                        if (dataTypeModel.InitialValue != null)
                                                        {
                                                            dataValueNumeric += dataTypeModel.InitialValue.Value;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (dataTypeModel.ClearValue != null)
                                                        {

                                                            if (dataValueNumeric >= dataTypeModel.ClearValue.Value - dataTypeModel.ClearErrorValue && dataValueNumeric <= dataTypeModel.ClearValue.Value + dataTypeModel.ClearErrorValue)
                                                            {
                                                                dataValueNumeric += double.Parse(lastRecord.DataValue);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            break;
                                        case Model.Monitor.eSourceType.Virtual:
                                            {
                                                if (lastRecord == null)
                                                {
                                                    if (dataTypeModel != null)
                                                    {
                                                        if (dataTypeModel.InitialValue != null)
                                                        {
                                                            dataValueNumeric += dataTypeModel.InitialValue.Value;
                                                        }
                                                    }
                                                }
                                                else
                                                {
                                                    if (double.TryParse(lastRecord.DataValue, out double last_value))
                                                    {
                                                        dataValueNumeric += last_value;
                                                    }
                                                }
                                            }
                                            break;
                                        default: break;
                                    }
                                }
                                break;
                        }

                        //数据过滤
                        if (signal.FilterParas != null)
                        {
                            double? lastDataValue = null;
                            if (lastRecord != null)
                            {
                                if (double.TryParse(lastRecord.DataValue, out double dataValueTemp))
                                {
                                    lastDataValue = dataValueTemp;
                                }
                            }
                            if (!signal.FilterParas.Filter(dataValueNumeric, lastDataValue))
                            {
                                dataStatus.Add(MonitorRecord.Status_FilterFailed);
                            }
                        }

                        //保留小数位数
                        if (signal.SignalType.DecimalPlaces != null)
                        {
                            dataValueNumeric = Math.Round(dataValueNumeric, signal.SignalType.DecimalPlaces.Value);
                        }

                        dataValue = dataValueNumeric.ToString();
                    }
                    break;
                case Model.Monitor.eValueType.Enum:
                    {
                        //数值转换
                        if (!double.TryParse(dataValue, out double dataValueEnum))
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换
                        if (signal.ConvertParas != null)
                        {
                            dataValueEnum = signal.ConvertParas.Convert(dataValueEnum, out bool succed);
                            if (!succed)
                            {
                                dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                            }
                        }

                        //数据修正
                        if (signal.CorrectParas != null)
                        {
                            dataValueEnum = signal.CorrectParas.Correct(dataValueEnum);
                        }

                        //数据过滤
                        if (signal.FilterParas != null)
                        {
                            double? lastDataValue = null;
                            if (lastRecord != null)
                            {
                                if (double.TryParse(lastRecord.DataValue, out double dataValueTemp))
                                {
                                    lastDataValue = dataValueTemp;
                                }
                            }
                            if (!signal.FilterParas.Filter(dataValueEnum, lastDataValue))
                            {
                                dataStatus.Add(MonitorRecord.Status_FilterFailed);
                            }
                        }

                        //保留小数位数
                        if (signal.SignalType.DecimalPlaces != null)
                        {
                            dataValueEnum = Math.Round(dataValueEnum, signal.SignalType.DecimalPlaces.Value);
                        }

                        dataValue = dataValueEnum.ToString();
                    }
                    break;
                case Model.Monitor.eValueType.Array:
                    {
                        //数据格式验证
                        var dataValueArray = DoubleListHelper.ToList(dataValue);
                        if (dataValueArray == null || dataValueArray.Count < 1)
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换、修正、保留小数位数
                        var dataValueArrayNew = new List<double>();
                        foreach (var dataValueNumeric in dataValueArray)
                        {
                            var dataValueNumericNew = dataValueNumeric;

                            //数据转换
                            if (signal.ConvertParas != null)
                            {
                                dataValueNumericNew = signal.ConvertParas.Convert(dataValueNumericNew, out bool succed);
                                if (!succed)
                                {
                                    dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                                }
                            }

                            //数值修正
                            if (signal.CorrectParas != null)
                            {
                                dataValueNumericNew = signal.CorrectParas.Correct(dataValueNumericNew);
                            }

                            //保留小数位数
                            if (signal.SignalType.DecimalPlaces != null)
                            {
                                dataValueNumericNew = Math.Round(dataValueNumericNew, signal.SignalType.DecimalPlaces.Value);
                            }

                            dataValueArrayNew.Add(dataValueNumericNew);
                        }
                        dataValue = DoubleListHelper.ToString(dataValueArrayNew);
                    }
                    break;
                case Model.Monitor.eValueType.Integration:
                    {

                    }
                    break;
                default: break;
            }

            #endregion

            return dataValue;
        }

        /// <summary>
        /// 处理
        /// </summary>
        /// <param name="monitor">测点</param>
        /// <param name="signal">信号</param>
        /// <param name="last_record">最后一次记录</param>
        /// <param name="srcValue">原始值</param>
        /// <param name="dataStatus">数据状态</param>
        /// <returns>为空则不需要后续处理</returns>
        public static string Handle
            (
                Model.MonitorPoint monitor,
                Model.Signal_SignalType signal,
                Func<Model.MonitorBasicRecord> getLastRecord,
                DateTime srcTime,
                string srcValue,
                List<string> dataStatus
            )
        {
            //数据状态
            if (dataStatus == null)
            {
                dataStatus = new List<string>();
            }
            var dataValue = srcValue;//数据值
            Model.MonitorBasicRecord lastRecord = null;//最后一条记录

            #region 和最后一次记录对比，判断是否完全一样，并根据条件判断是否需要补充点

            if (monitor.CronType == Model.Monitor.eCronType.Real)
            {
                lastRecord = getLastRecord();
                if (lastRecord != null)
                {
                    if (lastRecord.SrcTime == srcTime)
                    {
                        //相同时间给出了相同值
                        if (lastRecord.SrcValue == srcValue)
                        {
                            var real_slot = Model.Monitor.RealSlot.ToModel(monitor.CronParas);
                            if (real_slot == null)
                            {
                                real_slot = new Model.Monitor.RealSlot();
                            }
                            if (!real_slot.UpdateWhenChanged)
                            {
                                return default;
                            }
                            dataStatus.Add(MonitorRecord.Status_Supplement);
                        }
                    }
                }
            }

            #endregion

            #region 通过信号类型的值类型和信号的数据类型进行相关的换算

            switch (signal.SignalType.ValueType)
            {
                case Model.Monitor.eValueType.Numeric:
                    {
                        //数值验证
                        if (!double.TryParse(dataValue, out double dataValueNumeric))
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换
                        if (signal.ConvertParas != null)
                        {
                            dataValueNumeric = signal.ConvertParas.Convert(dataValueNumeric, out bool succed);
                            if (!succed)
                            {
                                dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                            }
                        }

                        //数据修正
                        if (signal.CorrectParas != null)
                        {
                            dataValueNumeric = signal.CorrectParas.Correct(dataValueNumeric);
                        }

                        //类型特殊情况处理
                        switch (signal.DataType)
                        {
                            case Model.Monitor.eDataType.Instant://瞬时
                                {

                                }
                                break;
                            case Model.Monitor.eDataType.Accumulate://累积
                                {
                                    if (lastRecord == null)
                                    {
                                        if (monitor.CronType != Model.Monitor.eCronType.Real)
                                        {
                                            lastRecord = getLastRecord();
                                        }
                                    }
                                    var dataTypeModel = Model.Monitor.AccumulateParameters.ToModel(signal.DataParas);
                                    switch (monitor.SourceType)
                                    {
                                        case Model.Monitor.eSourceType.Docking:
                                            {
                                                if (dataTypeModel != null)
                                                {
                                                    if (lastRecord == null)
                                                    {
                                                        if (dataTypeModel.InitialValue != null)
                                                        {
                                                            dataValueNumeric += dataTypeModel.InitialValue.Value;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (dataTypeModel.ClearValue != null)
                                                        {

                                                            if (dataValueNumeric >= dataTypeModel.ClearValue.Value - dataTypeModel.ClearErrorValue && dataValueNumeric <= dataTypeModel.ClearValue.Value + dataTypeModel.ClearErrorValue)
                                                            {
                                                                dataValueNumeric += double.Parse(lastRecord.DataValue);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            break;
                                        case Model.Monitor.eSourceType.Analyse:
                                            {
                                                if (lastRecord == null)
                                                {
                                                    if (dataTypeModel != null)
                                                    {
                                                        if (dataTypeModel.InitialValue != null)
                                                        {
                                                            dataValueNumeric += dataTypeModel.InitialValue.Value;
                                                        }
                                                    }
                                                }
                                                else
                                                {
                                                    if (double.TryParse(lastRecord.DataValue, out double lastValueTemp))
                                                    {
                                                        dataValueNumeric += lastValueTemp;
                                                    }
                                                }
                                            }
                                            break;
                                        case Model.Monitor.eSourceType.Input:
                                            {
                                                if (dataTypeModel != null)
                                                {
                                                    if (lastRecord == null)
                                                    {
                                                        if (dataTypeModel.InitialValue != null)
                                                        {
                                                            dataValueNumeric += dataTypeModel.InitialValue.Value;
                                                        }
                                                    }
                                                    else
                                                    {
                                                        if (dataTypeModel.ClearValue != null)
                                                        {

                                                            if (dataValueNumeric >= dataTypeModel.ClearValue.Value - dataTypeModel.ClearErrorValue && dataValueNumeric <= dataTypeModel.ClearValue.Value + dataTypeModel.ClearErrorValue)
                                                            {
                                                                dataValueNumeric += double.Parse(lastRecord.DataValue);
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                            break;
                                        case Model.Monitor.eSourceType.Virtual:
                                            {
                                                if (lastRecord == null)
                                                {
                                                    if (dataTypeModel != null)
                                                    {
                                                        if (dataTypeModel.InitialValue != null)
                                                        {
                                                            dataValueNumeric += dataTypeModel.InitialValue.Value;
                                                        }
                                                    }
                                                }
                                                else
                                                {
                                                    if (double.TryParse(lastRecord.DataValue, out double lastValueTemp))
                                                    {
                                                        dataValueNumeric += lastValueTemp;
                                                    }
                                                }
                                            }
                                            break;
                                        default: break;
                                    }
                                }
                                break;
                            default: break;
                        }

                        //数据过滤
                        if (signal.FilterParas != null)
                        {
                            if (lastRecord == null)
                            {
                                if (monitor.CronType != Model.Monitor.eCronType.Real)
                                {
                                    if (signal.DataType != Model.Monitor.eDataType.Accumulate)
                                    {
                                        lastRecord = getLastRecord();
                                    }
                                }
                            }
                            double? lastDataValue = null;
                            if (lastRecord != null)
                            {
                                if (double.TryParse(lastRecord.DataValue, out double dataValueTemp))
                                {
                                    lastDataValue = dataValueTemp;
                                }
                            }
                            if (!signal.FilterParas.Filter(dataValueNumeric, lastDataValue))
                            {
                                dataStatus.Add(MonitorRecord.Status_FilterFailed);
                            }
                        }

                        //保留小数位数
                        if (signal.SignalType.DecimalPlaces != null)
                        {
                            dataValueNumeric = Math.Round(dataValueNumeric, signal.SignalType.DecimalPlaces.Value);
                        }

                        dataValue = dataValueNumeric.ToString();
                    }
                    break;
                case Model.Monitor.eValueType.Enum:
                    {
                        //数值转换
                        if (!double.TryParse(dataValue, out double dataValueEnum))
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换
                        if (signal.ConvertParas != null)
                        {
                            dataValueEnum = signal.ConvertParas.Convert(dataValueEnum, out bool succed);
                            if (!succed)
                            {
                                dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                            }
                        }

                        //数据修正
                        if (signal.CorrectParas != null)
                        {
                            dataValueEnum = signal.CorrectParas.Correct(dataValueEnum);
                        }

                        //数据过滤
                        if (signal.FilterParas != null)
                        {
                            if (lastRecord == null)
                            {
                                if (monitor.CronType != Model.Monitor.eCronType.Real)
                                {
                                    lastRecord = getLastRecord();
                                }
                            }
                            double? lastDataValue = null;
                            if (lastRecord != null)
                            {
                                lastDataValue = double.Parse(lastRecord.DataValue);
                            }
                            if (!signal.FilterParas.Filter(dataValueEnum, lastDataValue))
                            {
                                dataStatus.Add(MonitorRecord.Status_FilterFailed);
                            }
                        }

                        //保留小数位数
                        if (signal.SignalType.DecimalPlaces != null)
                        {
                            dataValueEnum = Math.Round(dataValueEnum, signal.SignalType.DecimalPlaces.Value);
                        }

                        dataValue = dataValueEnum.ToString();
                    }
                    break;
                case Model.Monitor.eValueType.Array:
                    {
                        //数据格式验证
                        var dataValueArray = DoubleListHelper.ToList(dataValue);
                        if (dataValueArray == null || dataValueArray.Count < 1)
                        {
                            dataStatus.Add(MonitorRecord.Status_DataFormatError);
                            break;
                        }

                        //数据转换、修正、保留小数位数
                        var dataValueArrayNew = new List<double>();
                        foreach (var dataValueNumeric in dataValueArray)
                        {
                            var dataValueNumericNew = dataValueNumeric;

                            //数据转换
                            if (signal.ConvertParas != null)
                            {
                                dataValueNumericNew = signal.ConvertParas.Convert(dataValueNumericNew, out bool succed);
                                if (!succed)
                                {
                                    dataStatus.Add(MonitorRecord.Status_ConvertFailed);
                                }
                            }

                            //数值修正
                            if (signal.CorrectParas != null)
                            {
                                dataValueNumericNew = signal.CorrectParas.Correct(dataValueNumericNew);
                            }

                            //保留小数位数
                            if (signal.SignalType.DecimalPlaces != null)
                            {
                                dataValueNumericNew = Math.Round(dataValueNumericNew, signal.SignalType.DecimalPlaces.Value);
                            }

                            dataValueArrayNew.Add(dataValueNumericNew);
                        }
                        dataValue = DoubleListHelper.ToString(dataValueArrayNew);
                    }
                    break;
                case Model.Monitor.eValueType.Integration:
                    {

                    }
                    break;
                default: break;
            }

            #endregion

            return dataValue;
        }

        /// <summary>
        /// 生成监测记录
        /// </summary>
        /// <returns></returns>
        public static Model.MonitorBasicRecord BuildMonitorRecord
            (
                Model.MonitorPoint monitor,
                Model.Signal_SignalType signal,
                DateTime srcTime,
                string srcValue,
                DateTime dataTime,
                string dataValue,
                List<string> dataStatus
            )
        {
            //最近一条记录
            Model.MonitorBasicRecord record = null;

            #region 监测记录生成

            switch (monitor.CronType)
            {
                case Model.Monitor.eCronType.Real:
                    {
                        var realRecord = new Model.MonitorRealRecordPure();
                        realRecord.CorpID = monitor.CorpID;
                        realRecord.MonitorPointID = monitor.ID;
                        realRecord.SignalID = signal.ID;
                        realRecord.RecordType = monitor.MonitorType;
                        realRecord.SrcTime = srcTime;
                        realRecord.SrcValue = srcValue;
                        realRecord.DataTime = dataTime;
                        realRecord.DataValue = dataValue;
                        realRecord.DataStatus = dataStatus?.ToList();
                        record = realRecord;
                    }
                    break;
                case Model.Monitor.eCronType.EachHour:
                    {
                        var hourRecord = new Model.MonitorHourRecordPure();
                        hourRecord.CorpID = monitor.CorpID;
                        hourRecord.MonitorPointID = monitor.ID;
                        hourRecord.SignalID = signal.ID;
                        hourRecord.RecordType = monitor.MonitorType;
                        hourRecord.SrcTime = srcTime;
                        hourRecord.SrcValue = srcValue;
                        hourRecord.DataDay = dataTime.AddHours(-1).Date;
                        hourRecord.DataHour = dataTime.AddHours(-1).Hour + 1;
                        hourRecord.DataTime = dataTime;
                        hourRecord.DataValue = dataValue;
                        hourRecord.DataStatus = dataStatus?.ToList();
                        record = hourRecord;
                    }
                    break;
                case Model.Monitor.eCronType.EachDay:
                    {
                        var dayRecord = new Model.MonitorDayRecordPure();
                        dayRecord.CorpID = monitor.CorpID;
                        dayRecord.MonitorPointID = monitor.ID;
                        dayRecord.SignalID = signal.ID;
                        dayRecord.RecordType = monitor.MonitorType;
                        dayRecord.SrcTime = srcTime;
                        dayRecord.SrcValue = srcValue;
                        dayRecord.DataDay = dataTime.AddDays(-1).Date;
                        dayRecord.DataTime = dataTime;
                        dayRecord.DataValue = dataValue;
                        dayRecord.DataStatus = dataStatus?.ToList();
                        record = dayRecord;
                    }
                    break;
                case Model.Monitor.eCronType.EachWeek:
                    {
                        var weekRecord = new Model.MonitorWeekRecordPure();
                        weekRecord.CorpID = monitor.CorpID;
                        weekRecord.MonitorPointID = monitor.ID;
                        weekRecord.SignalID = signal.ID;
                        weekRecord.RecordType = monitor.MonitorType;
                        weekRecord.SrcTime = srcTime;
                        weekRecord.SrcValue = srcValue;
                        weekRecord.DataTime = dataTime;
                        weekRecord.DataValue = dataValue;
                        weekRecord.DataStatus = dataStatus?.ToList();
                        var cron_week = Model.Monitor.WeekSlot.ToModel(monitor.CronParas);
                        if (cron_week == null)
                            cron_week = new Model.Monitor.WeekSlot();
                        weekRecord.StartDay = cron_week.GetStartTime(dataTime).Date;
                        weekRecord.EndDay = cron_week.GetEndTime(dataTime).AddDays(-1).Date;
                        record = weekRecord;
                    }
                    break;
                case Model.Monitor.eCronType.EachMonth:
                    {
                        var monthRecord = new Model.MonitorMonthRecordPure();
                        monthRecord.CorpID = monitor.CorpID;
                        monthRecord.MonitorPointID = monitor.ID;
                        monthRecord.SignalID = signal.ID;
                        monthRecord.RecordType = monitor.MonitorType;
                        monthRecord.SrcTime = srcTime;
                        monthRecord.SrcValue = srcValue;
                        monthRecord.DataYear = dataTime.AddMonths(-1).Year;
                        monthRecord.DataMonth = dataTime.AddMonths(-1).Month;
                        monthRecord.DataTime = dataTime;
                        monthRecord.DataValue = dataValue;
                        monthRecord.DataStatus = dataStatus?.ToList();
                        record = monthRecord;
                    }
                    break;
                case Model.Monitor.eCronType.EachYear:
                    {
                        var yearRecord = new Model.MonitorYearRecordPure();
                        yearRecord.CorpID = monitor.CorpID;
                        yearRecord.MonitorPointID = monitor.ID;
                        yearRecord.SignalID = signal.ID;
                        yearRecord.RecordType = monitor.MonitorType;
                        yearRecord.SrcTime = srcTime;
                        yearRecord.SrcValue = srcValue;
                        yearRecord.DataYear = dataTime.AddYears(-1).Year;
                        yearRecord.DataTime = dataTime;
                        yearRecord.DataValue = dataValue;
                        yearRecord.DataStatus = dataStatus?.ToList();
                        record = yearRecord;
                    }
                    break;
                default: break;
            }

            #endregion

            return record;
        }

    }
}