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

namespace IStation.Server
{
    /// <summary>
    /// 监测处理辅助类
    /// </summary>
    public class MonitorHandleHelper 
    {

        /// <summary>
        /// 处理
        /// </summary>
        public static bool Handle(Model.MonitorDataDockingCorpRecord data)
        {
            try
            {

                #region 数据验证

                if (data == null)
                {
                    LogHelper.Info("监测接收数据处理中，监测接收数据序列化失败，自动跳过当前数据!");
                    return true;
                }
                if (data.Records == null || data.Records.Count < 1)
                {
                    LogHelper.Info($"监测接收数据处理中，客户标识：{data.CorpID},配置标识：{data.ConfigureID},接收记录为空，自动跳过当前数据!");
                    return true;
                }
                data.Records = data.Records.Where(x => !string.IsNullOrEmpty(x.SrcValue)).ToList();
                if (data.Records.Count < 1)
                {
                    LogHelper.Info($" 监测接收数据处理中，客户标识：{data.CorpID}，配置标识：{data.ConfigureID}，有效接收记录为空，自动跳过当前数据！");
                    return true;
                }
                var configure = new Service.DataDockingConfigure().GetByID(data.CorpID, data.ConfigureID);
                if (configure == null)
                {
                    LogHelper.Info($"监测接收数据处理中，客户标识:{data.CorpID}，配置标识:{data.ConfigureID},未检索到数据对接配置信息，自动跳过当前数据！");
                    return true;
                }
                if (configure.UseStatus != Model.eUseStatus.Enable)
                {
                    LogHelper.Info($"监测接收数据处理中，客户标识:{data.CorpID}，配置标识:{data.ConfigureID},未检索到有效数据对接配置信息，自动跳过当前数据！");
                    return true;
                }

                #endregion

                #region 处理日志

                if (ConfigHelper.IsWriteLog)
                {
                    LogHelper.Info($"监测接收数据处理中,处理数据:客户标识:{data.CorpID},配置标识:{data.ConfigureID},数据数量:{data.Records.Count}");
                }

                #endregion

                #region 流程记录生成

                var sysId_list = data.Records.Select(x => x.SysId).ToList();
                var dataDockingRecord = new Model.MonitorDataDockingFlowRecord();
                dataDockingRecord.CorpID = data.CorpID;
                dataDockingRecord.ConfigureID = data.ConfigureID;
                dataDockingRecord.DockingTime =DateTime.Now;
                dataDockingRecord.DockingCount = data.Records.Count;
                dataDockingRecord.DockingContent = sysId_list;
                new RedisCache.MonitorDataDockingFlowRecordCacheHelper().SetLastRecord(dataDockingRecord);

                #endregion

                #region 数据处理

                var monitor_list = new Service.MonitorPoint().GetExSignalWithSignalTypeByIds(data.CorpID, data.Records.Select(x => x.SysId).ToList());
                if (monitor_list == null || monitor_list.Count < 1)
                {
                    LogHelper.Info($"监测接收数据处理中，客户标识:{data.CorpID},配置标识:{data.ConfigureID} 未检索到测点信息，自动跳过当前数据！");
                    return true;
                }
                monitor_list = monitor_list.Where(x => x.UseStatus == Model.eUseStatus.Enable).ToList();
                if (monitor_list.Count < 1)
                {
                    LogHelper.Info($"监测接收数据处理中，客户标识:{data.CorpID},配置标识:{data.ConfigureID} 未检索到有效测点信息，自动跳过当前数据！");
                    return true;
                }

                //最后一次记录列表
                var record_last_list = RecordCacheHelper.Get(data.CorpID,monitor_list.Select(x=>x.ID).Distinct());
                if (record_last_list == null || record_last_list.Count < 1)
                {
                    record_last_list = new RedisCache.MonitorRecordCacheHelper().GetLastRecord(data.CorpID, monitor_list.Select(x => x.ID));
                }

                //保持数据时间的统一
                var dt_now = DateTime.Now;

                //遍历处理
                var record_list = new List<Model.MonitorBasicRecord>();
                foreach (var monitor in monitor_list)
                {
                    switch (monitor.MonitorType)
                    {
                        case Model.eMonitorType.General:
                            {
                                //信号
                                var signal = monitor.SignalList.FirstOrDefault();
                                if (signal == null)
                                {
                                    break;
                                }
                                //对接记录
                                var record_docking = data.Records.Find(t => t.SysId == monitor.ID);
                                if (record_docking == null)
                                {
                                    break;
                                }
                                if (record_docking.RecordType != Model.eMonitorType.General)
                                {
                                    break;
                                }
                                //上一次记录
                                var record_last = record_last_list?.Find(x => x.MonitorPointID == monitor.ID);
                                var record =Calculation.MonitorHandleHelper.Handle(monitor,signal,record_docking,record_last, dt_now);
                                if (record != null)
                                    record_list.Add(record);

                            }
                            break;
                        case Model.eMonitorType.Vibration:
                            {
                                //对接记录
                                var record_docking = data.Records.Find(t => t.SysId == monitor.ID);
                                if (record_docking == null)
                                {
                                    break;
                                }
                                if (record_docking.RecordType != Model.eMonitorType.Vibration)
                                {
                                    break;
                                }
                                var sub_record_list = Model.MonitorDataDockingReceiveSubRecord.ToList(record_docking.SrcValue);
                                if (sub_record_list != null && sub_record_list.Count > 0)
                                {
                                    foreach (var sub_record in sub_record_list)
                                    {
                                        var signal = monitor.SignalList?.FirstOrDefault(x => x.ID == sub_record.SysId);
                                        if (signal == null)
                                            continue;
                                        var record_docking_sub = new Model.MonitorDataDockingReceiveRecord()
                                        {
                                            SysId = record_docking.SysId,
                                            RecordType = record_docking.RecordType,
                                            SrcTime = record_docking.SrcTime,
                                            SrcValue = sub_record.SrcValue,
                                            DataStatus=record_docking.DataStatus
                                        };
                                        var record_last = record_last_list?.Find(x => x.MonitorPointID == monitor.ID && x.SignalID == sub_record.SysId);
                                        var record = Calculation.MonitorHandleHelper.Handle(monitor,signal,record_docking_sub,record_last,dt_now);
                                        if(record!=null)
                                            record_list.Add(record);
                                    }
                                }
                            }
                            break;
                        default: 
                            {
                                LogHelper.Error($"接收数据记录处理中，客户标识:{data.CorpID},配置标识：{data.ConfigureID}, 测点标识:{monitor.ID} 的监测类型为:{monitor.MonitorType},暂时不支持对接！");
                            }
                            break; 
                    }
                }

                //数据判断
                if (record_list == null || record_list.Count < 1)
                {
                    LogHelper.Error($"接收记录数据处理中，客户标识:{data.CorpID},配置标识：{data.ConfigureID},数据处理后为空,自动跳过当前数据！");
                    return true;
                }

                RecordCacheHelper.Set(data.CorpID,record_list);

                #endregion

                #region 数据存储

                #region 实时记录

                var record_real_list = record_list.Where(x => x is Model.MonitorRealRecordPure).Select(x => x as Model.MonitorRealRecordPure).ToList();
                if (record_real_list != null && record_real_list.Count > 0)
                {
                    var result = new Service.MonitorRealRecord().InsertsLastRecord(record_real_list);
                    if (!result)
                    {
                        LogHelper.Info($"数据处理中,客户标识:{data.CorpID},配置标识：{data.ConfigureID} 实时数据存储失败！");
                    }
                    else
                    {
                        if (ConfigHelper.IsWriteLog)
                        {
                            LogHelper.Info($"监测接收数据处理中,保存实时记录:客户标识:{data.CorpID},配置标识:{data.ConfigureID},数据数量:{record_real_list.Count}");
                        }
                    }
                }

                #endregion

                #region 时记录

                var record_hour_list = record_list.Where(x => x is Model.MonitorHourRecordPure).Select(x => x as Model.MonitorHourRecordPure).ToList();
                if (record_hour_list != null && record_hour_list.Count > 0)
                {
                    var result = new Service.MonitorHourRecord().InsertsLastRecord(record_hour_list);
                    if (!result)
                    {
                        LogHelper.Info($"数据处理中,客户标识:{data.CorpID},配置标识：{data.ConfigureID} 时数据存储失败！");
                    }
                    else
                    {
                        if (ConfigHelper.IsWriteLog)
                        {
                            LogHelper.Info($"监测接收数据处理中,保存时记录:客户标识:{data.CorpID},配置标识:{data.ConfigureID},数据数量:{record_hour_list.Count}");
                        }
                    }
                }

                #endregion

                #region 日记录

                var record_day_list = record_list.Where(x => x is Model.MonitorDayRecordPure).Select(x => x as Model.MonitorDayRecordPure).ToList();
                if (record_day_list != null && record_day_list.Count > 0)
                {
                    var result = new Service.MonitorDayRecord().InsertsLastRecord(record_day_list);
                    if (!result)
                    {
                        LogHelper.Info($"数据处理中,客户标识:{data.CorpID},配置标识：{data.ConfigureID} 日数据存储失败！");
                    }
                    else
                    {
                        if (ConfigHelper.IsWriteLog)
                        {
                            LogHelper.Info($"监测接收数据处理中,保存日记录:客户标识:{data.CorpID},配置标识:{data.ConfigureID},数据数量:{record_day_list.Count}");
                        }
                    }
                }

                #endregion

                #region 周记录

                var record_week_list = record_list.Where(x => x is Model.MonitorWeekRecordPure).Select(x => x as Model.MonitorWeekRecordPure).ToList();
                if (record_week_list != null && record_week_list.Count > 0)
                {
                    var result = new Service.MonitorWeekRecord().InsertsLastRecord(record_week_list);
                    if (!result)
                    {
                        LogHelper.Error($"数据处理中,客户标识:{data.CorpID},配置标识：{data.ConfigureID} 周数据存储失败！");
                    }
                    else
                    {
                        if (ConfigHelper.IsWriteLog)
                        {
                            LogHelper.Info($"监测接收数据处理中,保存周记录:客户标识:{data.CorpID},配置标识:{data.ConfigureID},数据数量:{record_week_list.Count}");
                        }
                    }
                }

                #endregion

                #region 月记录

                var record_month_list = record_list.Where(x => x is Model.MonitorMonthRecordPure).Select(x => x as Model.MonitorMonthRecordPure).ToList();
                if (record_month_list != null && record_month_list.Count > 0)
                {
                    var result = new Service.MonitorMonthRecord().InsertsLastRecord(record_month_list);
                    if (!result)
                    {
                        LogHelper.Error($"数据处理中,客户标识:{data.CorpID},配置标识：{data.ConfigureID} 月数据存储失败！");
                    }
                    else
                    {
                        if (ConfigHelper.IsWriteLog)
                        {
                            LogHelper.Info($"监测接收数据处理中,保存月记录:客户标识:{data.CorpID},配置标识:{data.ConfigureID},数据数量:{record_month_list.Count}");
                        }
                    }
                }

                #endregion

                #region 年记录

                var record_year_list = record_list.Where(x => x is Model.MonitorYearRecordPure).Select(x => x as Model.MonitorYearRecordPure).ToList();
                if (record_year_list != null && record_year_list.Count > 0)
                {
                    var result = new Service.MonitorYearRecord().InsertsLastRecord(record_year_list);
                    if (!result)
                    {
                        LogHelper.Error($"数据处理中,客户标识:{data.CorpID},配置标识：{data.ConfigureID} 年数据存储失败！");
                    }
                    else
                    {
                        if (ConfigHelper.IsWriteLog)
                        {
                            LogHelper.Info($"监测接收数据处理中,保存年记录:客户标识:{data.CorpID},配置标识:{data.ConfigureID},数据数量:{record_year_list.Count}");
                        }
                    }
                }

                #endregion

                #endregion

                #region 运行数据分发

                var runQueue = new RabbitMqExChangeHelper();
                runQueue.Push(ConfigHelper.RunExchangeName, record_list);

                #endregion

                return true;

            }
            catch (Exception ex)
            {
                LogHelper.Error("接收数据记录处理失败，自动跳过当前数据！", ex);
                return true;
            }
        }




    }
}