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

namespace IStation.Service
{
    /// <summary>
    /// 实时监测记录
    /// </summary>
    public partial class MonitorRealRecord
    {
        #region 最近一条记录

        /// <summary>
        /// 获取最近一条记录
        /// </summary>
        public Model.MonitorRealRecordPure GetLastRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            var redisHelper = new MonitorRecordCacheHelper();
            var record = redisHelper.GetLastRealRecord(CorpID, MonitorPointID, SignalID);
            return record;
        }

        /// <summary>
        /// 获取最近一条记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastRecord(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds)
        {
            if (SignalIds == null || SignalIds.Count() < 1)
                return default;
            var redisHelper = new MonitorRecordCacheHelper();
            var records = redisHelper.GetLastRealRecord(CorpID, MonitorPointID,SignalIds);
            return records;
        }

        /// <summary>
        /// 获取最近一条记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastRecord(long CorpID, Dictionary<long, long> dict)
        {
            if (dict == null || dict.Count < 1)
                return default;
            var redisHelper = new MonitorRecordCacheHelper();
            var records = redisHelper.GetLastRealRecord(CorpID, dict);
            return records;
        }

        /// <summary>
        /// 获取最近一条记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastRecord(long CorpID, long MonitorPointID)
        {
            var redisHelper = new MonitorRecordCacheHelper();
            var records = redisHelper.GetLastRealRecord(CorpID, MonitorPointID);
            return records;
        }

        /// <summary>
        /// 获取最近一条记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            if (MonitorPointIds == null || MonitorPointIds.Count() < 1)
                return default;
            var redisHelper = new MonitorRecordCacheHelper();
            var records = redisHelper.GetLastRealRecord(CorpID, MonitorPointIds);
            return records;
        }

        /// <summary>
        /// 获取最近一条正常记录
        /// </summary>
        public Model.MonitorRealRecordPure GetLastNormalRecord(long CorpID, long MonitorPointID, long SignalID)
        {
            var redisHelper = new MonitorRecordCacheHelper();
            var record = redisHelper.GetLastNormalRealRecord(CorpID, MonitorPointID, SignalID);
            return record;
        }

        /// <summary>
        /// 获取最近一条正常记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastNormalRecord(long CorpID, Dictionary<long, long> dict)
        {
            if (dict == null || dict.Count < 1)
                return default;
            var redisHelper = new MonitorRecordCacheHelper();
            var records = redisHelper.GetLastNormalRealRecord(CorpID, dict);
            return records;
        }

        /// <summary>
        /// 获取最近一条正常记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastNormalRecord(long CorpID, long MonitorPointID)
        {
            var redisHelper = new MonitorRecordCacheHelper();
            var records = redisHelper.GetLastNormalRealRecord(CorpID, MonitorPointID);
            return records;
        }

        /// <summary>
        /// 获取最近一条正常记录
        /// </summary>
        public List<Model.MonitorRealRecordPure> GetLastNormalRecord(long CorpID, IEnumerable<long> MonitorPointIds)
        {
            if (MonitorPointIds == null || MonitorPointIds.Count() < 1)
                return default;
            var redisHelper = new MonitorRecordCacheHelper();
            var records = redisHelper.GetLastNormalRealRecord(CorpID, MonitorPointIds);
            return records;
        }

        #endregion

        #region 通过 MonitorPointID 获取

        /// <summary>
        /// 通过 MonitorPointID 获取某一天的数据
        /// </summary>
        public List<Model.MonitorRealRecord> GetByMonitorPointIDOfDay(long CorpID, long MonitorPointID, DateTime Day)
        {
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetByMonitorPointIDOfDay(CorpID, MonitorPointID, Day);
            return Entity2Models(entity_list);
        }

        /// <summary>
        /// 通过 MonitorPointID 获取某一天固定数量的数据
        /// </summary>
        public List<Model.MonitorRealRecord> GetFixedByMonitorPointIDOfDay(long CorpID, long MonitorPointID, DateTime Day, int Fixed)
        {
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetFixedByMonitorPointIDOfDay(CorpID, MonitorPointID, Day, Fixed);
            return Entity2Models(entity_list);
        }

        /// <summary>
        /// 通过 MonitorPointID 获取某一天的内容数据
        /// </summary>
        public List<Model.MonitorRealRecordSignalContent> GetContentByMonitorPointIDOfDay(long CorpID, long MonitorPointID, DateTime Day)
        {
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetByMonitorPointIDOfDay(CorpID, MonitorPointID, Day);
            return Entity2SignalContents(entity_list); 
        }

        /// <summary>
        /// 通过 MonitorPointID 获取某一天固定数量的内容数据
        /// </summary>
        public List<Model.MonitorRealRecordSignalContent> GetFixedContentByMonitorPointIDOfDay(long CorpID, long MonitorPointID, DateTime Day, int Fixed)
        {
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetFixedByMonitorPointIDOfDay(CorpID, MonitorPointID, Day,Fixed);
            return Entity2SignalContents(entity_list);
        }

        /// <summary>
        /// 通过 MonitorPointID 获取日期区间内的数据
        /// </summary>
        public List<Model.MonitorRealRecord> GetByMonitorPointIDOfDayRange(long CorpID, long MonitorPointID, DateTime StartDay, DateTime EndDay)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay);
            return Entity2Models(entity_list);
        }

        /// <summary>
        /// 通过 MonitorPointID 获取日期区间内固定数量的数据
        /// </summary>
        public List<Model.MonitorRealRecord> GetFixedByMonitorPointIDOfDayRange(long CorpID, long MonitorPointID, DateTime StartDay, DateTime EndDay, int Fixed)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetFixedByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay,Fixed);
            return Entity2Models(entity_list);
        }

        /// <summary>
        /// 通过 MonitorPointID 获取日期区间内的内容数据
        /// </summary>
        public List<Model.MonitorRealRecordSignalContent> GetContentByMonitorPointIDOfDayRange(long CorpID, long MonitorPointID, DateTime StartDay, DateTime EndDay)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay);
            return Entity2SignalContents(entity_list);
        }

        /// <summary>
        /// 通过 MonitorPointID 获取日期区间内的内容数据
        /// </summary>
        public List<Model.MonitorRealRecordSignalContent> GetFixedContentByMonitorPointIDOfDayRange(long CorpID, long MonitorPointID, DateTime StartDay, DateTime EndDay, int Fixed)
        {
            if (StartDay.Date > EndDay.Date)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetFixedByMonitorPointIDOfDayRange(CorpID, MonitorPointID, StartDay, EndDay,Fixed);
            return Entity2SignalContents(entity_list);
        }

        /// <summary>
        /// 通过 MonitorPointID 获取时间区间内的数据
        /// </summary>
        public List<Model.MonitorRealRecord> GetByMonitorPointIDOfTimeRange(long CorpID, long MonitorPointID, DateTime StartTime, DateTime EndTime)
        {
            if (StartTime > EndTime)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime);
            return Entity2Models(entity_list);
        }

        /// <summary>
        /// 通过 MonitorPointID 获取时间区间内固定数量的数据
        /// </summary>
        public List<Model.MonitorRealRecord> GetFixedByMonitorPointIDOfTimeRange(long CorpID, long MonitorPointID, DateTime StartTime, DateTime EndTime, int Fixed)
        {
            if (StartTime > EndTime)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetFixedByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime,Fixed);
            return Entity2Models(entity_list);
        }

        /// <summary>
        /// 通过 MonitorPointID 获取时间区间内的内容数据
        /// </summary>
        public List<Model.MonitorRealRecordSignalContent> GetContentByMonitorPointIDOfTimeRange(long CorpID, long MonitorPointID, DateTime StartTime, DateTime EndTime)
        {
            if (StartTime > EndTime)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime);
            return Entity2SignalContents(entity_list);
        }

        /// <summary>
        /// 通过 MonitorPointID 获取时间区间内固定数量的内容数据
        /// </summary>
        public List<Model.MonitorRealRecordSignalContent> GetFixedContentByMonitorPointIDOfTimeRange(long CorpID, long MonitorPointID, DateTime StartTime, DateTime EndTime, int Fixed)
        {
            if (StartTime > EndTime)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetFixedByMonitorPointIDOfTimeRange(CorpID, MonitorPointID, StartTime, EndTime,Fixed);
            return Entity2SignalContents(entity_list);
        }


        #endregion

        #region 通过 SignalID 获取

        /// <summary>
        /// 通过 SignalID 获取某一时刻数据
        /// </summary>
        public Model.MonitorRealRecord GetBySignalIDOfDataTime(long CorpID, long MonitorPointID, long SignalID, DateTime DataTime)
        {
            var dal = new DAL.MonitorRealRecord();
            var entity = dal.GetBySignalIDOfDataTime(CorpID,MonitorPointID,SignalID,DataTime);
            return Entity2Model(entity);
        }

        /// <summary>
        /// 通过 SignalID 获取某天的数据
        /// </summary>
        public List<Model.MonitorRealRecord> GetBySignalIDOfDay(long CorpID, long MonitorPointID, long SignalID, DateTime Day)
        {
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetBySignalIDOfDay(CorpID, MonitorPointID, SignalID, Day);
            return Entity2Models(entity_list);
        }

        /// <summary>
        /// 通过 SignalID 获取某天的第一条数据
        /// </summary>
        public Model.MonitorRealRecord GetFirstBySignalIDOfDay(long CorpID, long MonitorPointID, long SignalID, DateTime Day)
        {
            var dal = new DAL.MonitorRealRecord();
            var entity = dal.GetFirstBySignalIDOfDay(CorpID,MonitorPointID,SignalID,Day);
            return Entity2Model(entity);
        }

        /// <summary>
        /// 通过 SignalID 获取某天的最后一条数据
        /// </summary>
        public Model.MonitorRealRecord GetLastBySignalIDOfDay(long CorpID, long MonitorPointID, long SignalID, DateTime Day)
        {
            var dal = new DAL.MonitorRealRecord();
            var entity = dal.GetLastBySignalIDOfDay(CorpID, MonitorPointID, SignalID, Day);
            return Entity2Model(entity);
        }

        /// <summary>
        /// 通过 SignalID 获取某天的数据
        /// </summary>
        public List<Model.MonitorRealRecord> GetBySignalIdsOfDay(long CorpID, long MonitorPointID, IEnumerable<long> SignalIds, DateTime Day)
        {
            if (SignalIds == null || SignalIds.Count() < 1)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetBySignalIdsOfDay(CorpID, MonitorPointID, SignalIds, Day);
            return Entity2Models(entity_list);
        }

        /// <summary>
        /// 通过 SignalID 获取某天的内容数据
        /// </summary>
        public List<Model.MonitorRealRecordContent> GetContentBySignalIDOfDay(long CorpID, long MonitorPointID, long SignalID, DateTime Day)
        {
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetBySignalIDOfDay(CorpID, MonitorPointID,SignalID, Day);
            return Entity2Contents(entity_list);
        }

        /// <summary>
        /// 通过 SignalID 获取时间区间内的数据
        /// </summary>
        public List<Model.MonitorRealRecord> GetBySignalIDOfTimeRange(long CorpID, long MonitorPointID, long SignalID, DateTime StartTime, DateTime EndTime)
        {
            if (StartTime > EndTime)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entityList = dal.GetBySignalIDOfTimeRange(CorpID, MonitorPointID, SignalID, StartTime, EndTime);
            var modelList= Entity2Models(entityList);
            return modelList;
        }

        /// <summary>
        /// 通过 SignalID 获取时间区间内的固定数量的数据
        /// </summary>
        public List<Model.MonitorRealRecord> GetFixedBySignalIDOfTimeRange(long CorpID, long MonitorPointID, long SignalID, int Fixed, DateTime StartTime, DateTime EndTime)
        {
            if (StartTime > EndTime)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entityList = dal.GetFixedBySignalIDOfTimeRange(CorpID, MonitorPointID, SignalID, Fixed, StartTime, EndTime);
            var modelList=Entity2Models(entityList);
            return modelList;
        }



        /// <summary>
        /// 通过 SignalID 获取时间区间内的内容数据
        /// </summary>
        public List<Model.MonitorRealRecordContent> GetContentBySignalIDOfTimeRange(long CorpID, long MonitorPointID, long SignalID, DateTime StartTime, DateTime EndTime)
        {
            if (StartTime > EndTime)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetBySignalIDOfTimeRange(CorpID,MonitorPointID,SignalID,StartTime,EndTime);
            return Entity2Contents(entity_list);
        }

        /// <summary>
        /// 通过 SignalID 获取时间区间内的基础内容数据
        /// </summary>
        public List<Model.MonitorBasicRecordContent> GetBasicContentBySignalIDOfTimeRange(long CorpID, long MonitorPointID, long SignalID, DateTime StartTime, DateTime EndTime)
        {
            if (StartTime > EndTime)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetBySignalIDOfTimeRange(CorpID, MonitorPointID, SignalID, StartTime, EndTime);
            return Entity2BasicContents(entity_list);
        }

        /// <summary>
        /// 通过 SignalID 获取时间区间内的固定数量的基础内容数据
        /// </summary>
        public List<Model.MonitorBasicRecordContent> GetFixedBasicContentBySignalIDOfTimeRange(long CorpID, long MonitorPointID, long SignalID, int Fixed, DateTime StartTime, DateTime EndTime)
        {
            if (StartTime > EndTime)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = dal.GetFixedBySignalIDOfTimeRange(CorpID, MonitorPointID, SignalID,Fixed, StartTime, EndTime);
            return Entity2BasicContents(entity_list);
        }

        #endregion

        #region Insert

        /// <summary>
        /// 插入一条
        /// </summary>
        public long Insert(Model.MonitorRealRecordPure model)
        {
            if (model == null)
                return default;      
            var dal = new DAL.MonitorRealRecord();
            var entity = Model2Entity(model);
            var id = dal.Insert(entity);
            return id;
        }

        /// <summary>
        /// 插入多条
        /// </summary>
        public bool Inserts(List<Model.MonitorRealRecordPure> list)
        {
            if (list == null || list.Count < 1)
                return false;
            var dal = new DAL.MonitorRealRecord();
            var entity_list = Model2Entities(list);
            var bol = dal.Inserts(entity_list);
            return bol;
        }

        /// <summary>
        /// 插入
        /// </summary>
        public bool Insert(long CorpID,List<Model.MonitorStoreRecord> list)
        {
            if (list == null || list.Count < 1)
                return default;
            var models = list.Select(x => new Model.MonitorRealRecordPure()
            {
                CorpID = CorpID,
                MonitorPointID = x.MonitorPointID,
                SignalID = x.SignalID,
                RecordType = x.RecordType,
                SrcTime = x.SrcTime,
                SrcValue = x.SrcValue,
                DataTime = x.DataTime,
                DataValue = x.DataValue,
                DataStatus = x.DataStatus?.ToList()
            }).ToList();
            return Inserts(models);
        }

        /// <summary>
        /// 插入最近一条记录
        /// </summary>
        public bool InsertLastRecord(Model.MonitorRealRecordPure model)
        {
            if (model == null)
                return default;
            var queueHelper = new RabbitMqQueueHelper();
            var bol = queueHelper.Push(ConfigHelper.StoreQueueName, new Model.MonitorStoreCorpRecord()
            {
                CorpID = model.CorpID,
                Records = new List<Model.MonitorStoreRecord>()
                 {
                   Pure2Store(model)
                }
            });
            if (bol)
            {
                var redisHelper = new MonitorRecordCacheHelper();
                redisHelper.SetLastRealRecord(model);
            }

            return bol;
        }

        /// <summary>
        /// 插入最近多条记录
        /// </summary>
        public bool InsertsLastRecord(List<Model.MonitorRealRecordPure> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var queueHelper = new RabbitMqQueueHelper();
            var bol = queueHelper.Push(ConfigHelper.StoreQueueName, new Model.MonitorStoreCorpRecord()
            {
                CorpID = list.First().CorpID,
                Records = Pure2Stores(list)
            }) ;
            if (bol)
            {
                var redisHelper = new MonitorRecordCacheHelper();
                redisHelper.SetLastRealRecord(list);
            }

            return bol;
        }

        /// <summary>
        /// 补录一条
        /// </summary>
        public bool InsertSupplement(Model.MonitorRealRecordPure model)
        {
            if (model == null)
            {
                return default;
            }
            var queueHelper = new RabbitMqQueueHelper();
            var bol = queueHelper.Push(ConfigHelper.StoreQueueName, new Model.MonitorStoreCorpRecord()
            {
                CorpID = model.CorpID,
                Records =new List<Model.MonitorStoreRecord>() { Pure2Store(model) }
            }); ;
            return bol;
        }

        /// <summary>
        /// 补录多条
        /// </summary>
        public bool InsertsSupplement(List<Model.MonitorRealRecordPure> list)
        {
            if (list == null || list.Count() < 1)
            {
                return default;
            }
            var corpIds = list.Select(x => x.CorpID).Distinct().ToList();
            if (corpIds.Count > 1)
            {
                return default;
            }

            var queueHelper = new RabbitMqQueueHelper();
            var bol = queueHelper.Push(ConfigHelper.StoreQueueName, new Model.MonitorStoreCorpRecord()
            {
                CorpID = corpIds[0],
                Records = Pure2Stores(list)
            });
            return bol;
        }

        /// <summary>
        /// 重录一条
        /// </summary>
        public bool InsertAgain(Model.MonitorRealRecordPure model)
        {
            if (model == null)
                return false;
            var dal = new DAL.MonitorRealRecord();
            var result= dal.DeleteBySignalIDOfDataTime(model.CorpID,model.MonitorPointID,model.SignalID,model.DataTime);
            if (!result)
            {
                LogHelper.Info($"重录一条监测实时记录中，CorpID:{model.CorpID},MonitorPointID:{model.MonitorPointID},SignalID:{model.SignalID},DataTime:{model.DataTime:yyyy-MM-dd HH:mm:ss},未检索到已存在记录！");
            }
            var queueHelper = new RabbitMqQueueHelper();
            var bol = queueHelper.Push(ConfigHelper.StoreQueueName, new Model.MonitorStoreCorpRecord()
            {
                CorpID = model.CorpID,
                Records = new List<Model.MonitorStoreRecord>() { Pure2Store(model) }
            }); ;
            return bol;
        }

        /// <summary>
        /// 重录多条
        /// </summary>
        public bool InsertsAgain(List<Model.MonitorRealRecordPure> list)
        {
            if (list == null || list.Count < 1)
                return false;
            var corpIds = list.Select(x => x.CorpID).Distinct().ToList();
            if (corpIds.Count > 1)
            {
                return default;
            }
            var groupList = list.GroupBy(x => new { x.CorpID, x.MonitorPointID, x.SignalID }).ToList();
            var dal = new DAL.MonitorRealRecord();
            foreach (var group in groupList)
            {
                var startTime = group.Min(x=>x.DataTime);
                var endTime = group.Max(x=>x.DataTime);
                var result = dal.DeleteBySignalIDOfTimeRange(group.Key.CorpID, group.Key.MonitorPointID, group.Key.SignalID, startTime, endTime);
                if (!result)
                {
                    LogHelper.Info($"重录多条监测实时记录中，CorpID:{group.Key.CorpID},MonitorPointID:{group.Key.MonitorPointID},SignalID:{group.Key.SignalID},StartTime:{startTime:yyyy-MM-dd HH:mm:ss},EndTime:{endTime:yyyy-MM-dd HH:mm:ss},未检索到已存在记录！");
                }
            }
            var queueHelper = new RabbitMqQueueHelper();
            var bol = queueHelper.Push(ConfigHelper.StoreQueueName, new Model.MonitorStoreCorpRecord()
            {
                CorpID = corpIds[0],
                Records = Pure2Stores(list)
            });
            return bol;

        }

        #endregion

        #region Update

        /// <summary>
        /// 更新一条
        /// </summary>
        public bool Update(Model.MonitorRealRecord model)
        {
            if (model == null)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entity = Model2Entity(model);
            var bol = dal.Update(entity); 
            return bol;
        }

        /// <summary>
        /// 批量更新
        /// </summary>
        public bool Updates(List<Model.MonitorRealRecord> list)
        {
            if (list == null || list.Count < 1)
                return default;
            var dal = new DAL.MonitorRealRecord();
            var entityList = Model2Entities(list);
            var bol = dal.Updates(entityList);
            return bol;
        }


        #endregion

    }
}