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 MonitorYearRecord
    {
        #region 最近一条记录

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

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

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

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

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

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

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

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

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

        #endregion

        #region 历史记录

        /// <summary>
        /// 通过 MonitorPointID 获取
        /// </summary>
        public List<Model.MonitorYearRecord> GetByMonitorPointID(long CorpID, long MonitorPointID)
        {
            var dal = new DAL.MonitorYearRecord();
            var entity_list = dal.GetByMonitorPointID(CorpID, MonitorPointID);
            var model_list = Entity2Models(entity_list);
            return model_list?.OrderBy(x=>x.DataYear).ThenBy(x=>x.DataTime).ToList();
        }

        /// <summary>
        /// 通过 MonitorPointID 获取某年的数据
        /// </summary>
        public List<Model.MonitorYearRecord> GetByMonitorPointIDOfYear(long CorpID, long MonitorPointID, int Year)
        {
            var dal = new DAL.MonitorYearRecord();
            var entity_list = dal.GetByMonitorPointIDOfYear(CorpID, MonitorPointID, Year);
            var model_list = Entity2Models(entity_list);
            return model_list?.OrderBy(x => x.DataYear).ThenBy(x => x.DataTime).ToList();
        }

        /// <summary>
        /// 通过 MonitorPointID 获取年区间内的数据
        /// </summary>
        public List<Model.MonitorYearRecord> GetByMonitorPointIDOfYearRange(long CorpID, long MonitorPointID, int StartYear, int EndYear)
        {
            var dal = new DAL.MonitorYearRecord();
            var entity_list = dal.GetByMonitorPointIDOfYearRange(CorpID, MonitorPointID, StartYear, EndYear);
            var model_list = Entity2Models(entity_list);
            return model_list?.OrderBy(x => x.DataYear).ThenBy(x => x.DataTime).ToList();
        }

        /// <summary>
        /// 通过 SignalID 获取某年的数据
        /// </summary>
        public Model.MonitorYearRecord GetBySignalIDOfYear(long CorpID, long MonitorPointID, long SignalID, int Year)
        {
            var dal = new DAL.MonitorYearRecord();
            var entity = dal.GetBySignalIDOfYear(CorpID, MonitorPointID,SignalID, Year);
            var model = Entity2Model(entity);
            return model;
        }

        #endregion

        #region Insert

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

        /// <summary>
        /// 插入多条
        /// </summary>
        public bool Inserts(List<Model.MonitorYearRecordPure> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var dal = new DAL.MonitorYearRecord();
            var entity_list = Model2Entities(list.Select(x => new Model.MonitorYearRecord(x)).ToList()).ToList();
            var bol = dal.Inserts(entity_list);
            return bol;
        }

        /// <summary>
        /// 插入最近一条记录
        /// </summary>
        public bool InsertLastRecord(Model.MonitorYearRecordPure model)
        {
            if (model == null)
                return default;
            var dal = new DAL.MonitorYearRecord();
            var entity = Model2Entity(new Model.MonitorYearRecord(model));
            var bol = dal.Insert(entity)>0;
            if (bol)
            {
                var redisHelper = new MonitorRecordCacheHelper();
                redisHelper.SetLastYearRecord(model);
            }
            return bol;
        }

        /// <summary>
        /// 插入最近多条记录
        /// </summary>
        public bool InsertsLastRecord(List<Model.MonitorYearRecordPure> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var dal = new DAL.MonitorYearRecord();
            var entity_list = Model2Entities(list.Select(x => new Model.MonitorYearRecord(x)).ToList());
            var bol = dal.Inserts(entity_list);
            if (bol)
            {
                var redisHelper = new MonitorRecordCacheHelper();
                redisHelper.SetLastYearRecord(list);
            }
            return bol;
        }

        /// <summary>
        /// 补录一条
        /// </summary>
        public bool InsertSupplement(Model.MonitorYearRecordPure model)
        {
            if (model == null)
                return default;
            var dal = new DAL.MonitorYearRecord();
            var entity = Model2Entity(new Model.MonitorYearRecord(model));
            var id = dal.Insert(entity);
            return id>0;
        }

        /// <summary>
        /// 补录多条
        /// </summary>
        public bool InsertsSupplement(List<Model.MonitorYearRecordPure> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            var dal = new DAL.MonitorYearRecord();
            var entity_list = Model2Entities(list.Select(x=>new Model.MonitorYearRecord(x)).ToList()).ToList();
            var bol = dal.Inserts(entity_list);
            return bol;
        }

        /// <summary>
        /// 重录一条
        /// </summary>
        public bool InsertAgain(Model.MonitorYearRecordPure model)
        {
            if (model == null)
                return false;
            var dal = new DAL.MonitorYearRecord();
            var result = dal.DeleteBySignalIDOfYear(model.CorpID, model.MonitorPointID, model.SignalID, model.DataYear);
            if (!result)
            {
                LogHelper.Info($"重录一条监测年记录中，CorpID:{model.CorpID},MonitorPointID:{model.MonitorPointID},SignalID:{model.SignalID},DataYear:{model.DataYear},未检索到已存在记录！");
            }
            var entity = Model2Entity(new Model.MonitorYearRecord(model));
            var id = dal.Insert(entity);
            return id > 0;
        }

        /// <summary>
        /// 重录多条
        /// </summary>
        public bool InsertsAgain(List<Model.MonitorYearRecordPure> 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.MonitorYearRecord();
            foreach (var group in groupList)
            {
                var startYear = group.Min(x => x.DataYear);
                var endYear = group.Max(x => x.DataYear);
                var result = dal.DeleteBySignalIDOfYearRange(group.Key.CorpID, group.Key.MonitorPointID, group.Key.SignalID, startYear, endYear);
                if (!result)
                {
                    LogHelper.Info($"重录多条监测年记录中，CorpID:{group.Key.CorpID},MonitorPointID:{group.Key.MonitorPointID},SignalID:{group.Key.SignalID},StartYear:{startYear}, EndYear:{endYear},未检索到已存在记录！");
                }
            }
            var entityList = Model2Entities(list.Select(x => new Model.MonitorYearRecord(x)).ToList());
            var bol = dal.Inserts(entityList);
            return bol;
        }

        #endregion

        #region Update

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

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


        #endregion
    }
}