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

namespace IStation.RedisCache
{
    /// <summary>
    /// 
    /// </summary>
    public class EtaRealRecord
    {
        private const string _flag = "eta-real-record";//标志       
        private const string _lastRecord = "last-record";//最后一条记录      
        private const string _lastNormalRecord = "last-normal-record";//最后一条正常记录      
        private const string _lastAbnormalRecord = "last-abnormal-record";//最后一条不正常记录
        private const string _lastRunRecord = "last-run-record";//最后一次运行记录
        private const string _lastShutRecord = "last-shut-record";//最后一次停机记录

        //Redis客户端辅助类对象
        private readonly RedisClientHelper _redisClient = new RedisClientHelper();
        //创建RedisKey
        private static string CreateRedisKey(long CorpID, string ObjectType, long ObjectID)
        {
            return $"{RedisKeyHelper.CreateKey(_flag)}:{CorpID}:{ObjectType}-{ObjectID}";
        }

        #region Single

        /// <summary>
        /// 设置最后一条记录
        /// </summary>
        public void SetLastSingleRecord(Model.EtaSingleRealRecordPure model)
        {
            if (model == null)
                return;
            SetLastRecord(model);
            var redisKey= CreateRedisKey(model.CorpID, model.ObjectType, model.ObjectID);
            if (model.RSa == RunStatus.Run)
            {
                _redisClient.HashSetJosn(redisKey, _lastRunRecord, model);
            }
            else
            { 
                _redisClient.HashSetJosn(_lastRecord, _lastShutRecord, model);
            }
        }

        /// <summary>
        /// 设置最后一条记录
        /// </summary>
        public void SetLastSingleRecord(IEnumerable<Model.EtaSingleRealRecordPure> list)
        {
            list?.ToList().ForEach(x => SetLastSingleRecord(x));
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public Model.EtaSingleRealRecordPure GetLastSingleRecord(long CorpID, string ObjectType, long ObjectID) 
        {
            return GetLastRecord<Model.EtaSingleRealRecordPure>(CorpID, ObjectType, ObjectID);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.EtaSingleRealRecordPure> GetLastSingleRecord(long CorpID,string ObjectType,IEnumerable<long> ObjectIds)
        {
            return GetLastRecord<Model.EtaSingleRealRecordPure>(CorpID,ObjectType,ObjectIds);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.EtaSingleRealRecordPure> GetLastSingleRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list) 
        {
            return GetLastRecord<Model.EtaSingleRealRecordPure>(CorpID,list);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public Model.EtaSingleRealRecordPure GetLastNormalSingleRecord(long CorpID, string ObjectType, long ObjectID)
        {
            return GetLastNormalRecord<Model.EtaSingleRealRecordPure>(CorpID, ObjectType,ObjectID);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.EtaSingleRealRecordPure> GetLastNormalSingleRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            return GetLastNormalRecord<Model.EtaSingleRealRecordPure>(CorpID, ObjectType, ObjectIds);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.EtaSingleRealRecordPure> GetLastNormalSingleRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            return GetLastNormalRecord<Model.EtaSingleRealRecordPure>(CorpID,list);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public Model.EtaSingleRealRecordPure GetLastAbnormalSingleRecord(long CorpID, string ObjectType, long ObjectID)
        {
            return GetLastAbnormalRecord<Model.EtaSingleRealRecordPure>(CorpID, ObjectType, ObjectID);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.EtaSingleRealRecordPure> GetLastAbnormalSingleRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            return GetLastAbnormalRecord<Model.EtaSingleRealRecordPure>(CorpID, ObjectType, ObjectIds);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.EtaSingleRealRecordPure> GetLastAbnormalSingleRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            return GetLastAbnormalRecord<Model.EtaSingleRealRecordPure>(CorpID, list);
        }

        /// <summary>
        /// 获取最后一条开机记录
        /// </summary>
        public Model.EtaSingleRealRecordPure GetLastRunSingleRecord(long CorpID, string ObjectType, long ObjectID) 
        {
            var redisKey = CreateRedisKey(CorpID,ObjectType,ObjectID);
            return _redisClient.HashGetJson<Model.EtaSingleRealRecordPure>(redisKey,_lastRunRecord);
        }

        /// <summary>
        /// 获取最后一条开机记录
        /// </summary>
        public List<Model.EtaSingleRealRecordPure> GetLastRunSingleRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            return ObjectIds.Select(x => GetLastRunSingleRecord(CorpID, ObjectType, x)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条开机记录
        /// </summary>
        public List<Model.EtaSingleRealRecordPure> GetLastRunSingleRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            return list.Select(x => GetLastRunSingleRecord(CorpID, x.Key,x.Value)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条停机记录
        /// </summary>
        public Model.EtaSingleRealRecordPure GetLastShutSingleRecord(long CorpID, string ObjectType, long ObjectID)
        {
            var redisKey = CreateRedisKey(CorpID, ObjectType, ObjectID);
            return _redisClient.HashGetJson<Model.EtaSingleRealRecordPure>(redisKey, _lastShutRecord);
        }

        /// <summary>
        /// 获取最后一条停机记录
        /// </summary>
        public List<Model.EtaSingleRealRecordPure> GetLastShutSingleRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            return ObjectIds.Select(x => GetLastShutSingleRecord(CorpID, ObjectType, x)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条停机记录
        /// </summary>
        public List<Model.EtaSingleRealRecordPure> GetLastShutSingleRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            return list.Select(x => GetLastShutSingleRecord(CorpID, x.Key, x.Value)).Where(x => x != null).ToList();
        }


        #endregion

        #region Multi

        /// <summary>
        /// 设置最后一条记录
        /// </summary>
        public void SetLastMultiRecord(Model.EtaMultiRealRecordPure model)
        {
            if (model == null)
                return;
            SetLastRecord(model);
            var redisKey = CreateRedisKey(model.CorpID, model.ObjectType, model.ObjectID);
            if (model.RunningCount>0 )
            {
                _redisClient.HashSetJosn(redisKey, _lastRunRecord, model);
            }
            else
            {
                _redisClient.HashSetJosn(_lastRecord, _lastShutRecord, model);
            }
        }

        /// <summary>
        /// 设置最后一条记录
        /// </summary>
        public void SetLastMultiRecord(IEnumerable<Model.EtaMultiRealRecordPure> list)
        {
            list?.ToList().ForEach(x => SetLastMultiRecord(x));
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public Model.EtaMultiRealRecordPure GetLastMultiRecord(long CorpID, string ObjectType, long ObjectID) 
        {
            return GetLastRecord<Model.EtaMultiRealRecordPure>(CorpID, ObjectType, ObjectID);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastMultiRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            return GetLastRecord<Model.EtaMultiRealRecordPure>(CorpID, ObjectType, ObjectIds);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastMultiRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            return GetLastRecord<Model.EtaMultiRealRecordPure>(CorpID, list);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public Model.EtaMultiRealRecordPure GetLastNormalMultiRecord(long CorpID, string ObjectType, long ObjectID)
        {
            return GetLastNormalRecord<Model.EtaMultiRealRecordPure>(CorpID, ObjectType, ObjectID);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastNormalMultiRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            return GetLastNormalRecord<Model.EtaMultiRealRecordPure>(CorpID, ObjectType, ObjectIds);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastNormalMultiRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            return GetLastNormalRecord<Model.EtaMultiRealRecordPure>(CorpID, list);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public Model.EtaMultiRealRecordPure GetLastAbnormalMultiRecord(long CorpID, string ObjectType, long ObjectID)
        {
            return GetLastAbnormalRecord<Model.EtaMultiRealRecordPure>(CorpID, ObjectType, ObjectID);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastAbnormalMultiRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            return GetLastAbnormalRecord<Model.EtaMultiRealRecordPure>(CorpID, ObjectType, ObjectIds);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastAbnormalMultiRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            return GetLastAbnormalRecord<Model.EtaMultiRealRecordPure>(CorpID, list); 
        }

        /// <summary>
        /// 获取最后一条开机记录
        /// </summary>
        public Model.EtaMultiRealRecordPure GetLastRunMultiRecord(long CorpID, string ObjectType, long ObjectID)
        {
            var redisKey = CreateRedisKey(CorpID, ObjectType, ObjectID);
            return _redisClient.HashGetJson<Model.EtaMultiRealRecordPure>(redisKey, _lastRunRecord);
        }

        /// <summary>
        /// 获取最后一条开机记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastRunMultiRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            return ObjectIds.Select(x => GetLastRunMultiRecord(CorpID, ObjectType, x)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条开机记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastRunMultiRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            return list.Select(x => GetLastRunMultiRecord(CorpID, x.Key, x.Value)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条停机记录
        /// </summary>
        public Model.EtaMultiRealRecordPure GetLastShutMultiRecord(long CorpID, string ObjectType, long ObjectID)
        {
            var redisKey = CreateRedisKey(CorpID, ObjectType, ObjectID);
            return _redisClient.HashGetJson<Model.EtaMultiRealRecordPure>(redisKey, _lastShutRecord);
        }

        /// <summary>
        /// 获取最后一条停机记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastShutMultiRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            return ObjectIds.Select(x => GetLastShutMultiRecord(CorpID, ObjectType, x)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条停机记录
        /// </summary>
        public List<Model.EtaMultiRealRecordPure> GetLastShutMultiRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            if (list == null || list.Count() < 1)
                return default;
            return list.Select(x => GetLastShutMultiRecord(CorpID, x.Key, x.Value)).Where(x => x != null).ToList();
        }


        #endregion

        #region Logic

        /// <summary>
        /// 设置最后一条记录
        /// </summary>
        public void SetLastLogicRecord(Model.EtaLogicRealRecordPure model)
        {
            SetLastRecord(model);
        }

        /// <summary>
        /// 设置最后一条记录
        /// </summary>
        public void SetLastLogicRecord(IEnumerable<Model.EtaLogicRealRecordPure> list)
        {
            list?.ToList().ForEach(x => SetLastLogicRecord(x));
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public Model.EtaLogicRealRecordPure GetLastLogicRecord(long CorpID, string ObjectType, long ObjectID)
        {
            return GetLastRecord<Model.EtaLogicRealRecordPure>(CorpID, ObjectType, ObjectID);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.EtaLogicRealRecordPure> GetLastLogicRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            return GetLastRecord<Model.EtaLogicRealRecordPure>(CorpID, ObjectType, ObjectIds);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<Model.EtaLogicRealRecordPure> GetLastLogicRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            return GetLastRecord<Model.EtaLogicRealRecordPure>(CorpID, list);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public Model.EtaLogicRealRecordPure GetLastNormalLogicRecord(long CorpID, string ObjectType, long ObjectID)
        {
            return GetLastNormalRecord<Model.EtaLogicRealRecordPure>(CorpID, ObjectType, ObjectID);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.EtaLogicRealRecordPure> GetLastNormalLogicRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            return GetLastNormalRecord<Model.EtaLogicRealRecordPure>(CorpID, ObjectType, ObjectIds);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<Model.EtaLogicRealRecordPure> GetLastNormalLogicRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            return GetLastNormalRecord<Model.EtaLogicRealRecordPure>(CorpID, list);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public Model.EtaLogicRealRecordPure GetLastAbnormalLogicRecord(long CorpID, string ObjectType, long ObjectID)
        {
            return GetLastAbnormalRecord<Model.EtaLogicRealRecordPure>(CorpID, ObjectType, ObjectID);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.EtaLogicRealRecordPure> GetLastAbnormalLogicRecord(long CorpID, string ObjectType, IEnumerable<long> ObjectIds)
        {
            return GetLastAbnormalRecord<Model.EtaLogicRealRecordPure>(CorpID, ObjectType, ObjectIds);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<Model.EtaLogicRealRecordPure> GetLastAbnormalLogicRecord(long CorpID, IEnumerable<KeyValuePair<string, long>> list)
        {
            return GetLastAbnormalRecord<Model.EtaLogicRealRecordPure>(CorpID, list);
        }

        #endregion

        #region 最后一条记录

        /// <summary>
        /// 设置最后一条记录
        /// </summary>
        public void SetLastRecord<T>(T t) where T : Model.EtaBasicRealRecord
        {
            if (t == null)
                return;
            var redisKey = CreateRedisKey(t.CorpID, t.ObjectType, t.ObjectID);
            _redisClient.HashSetJosn(redisKey, _lastRecord, t);
            if (t.AnalyStatus == Model.Eta.eAnalyStatus.Normal)
            {
                _redisClient.HashSetJosn(redisKey, _lastNormalRecord, t);
            }
            else
            {
                _redisClient.HashSetJosn(redisKey, _lastAbnormalRecord, t);
            }
        }

        /// <summary>
        /// 设置最后一条记录
        /// </summary>
        public void SetLastRecord<T>(IEnumerable<T> list) where T : Model.EtaBasicRealRecord
        {
            if (list == null || list.Count() < 1)
                return;
            foreach (var item in list)
            {
                SetLastRecord(item);
            }
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public T GetLastRecord<T>(long CorpID, string ObjectType, long ObjectID) where T : Model.EtaBasicRealRecord
        {
            var redisKey = CreateRedisKey(CorpID, ObjectType, ObjectID);
            return _redisClient.HashGetJson<T>(redisKey, _lastRecord);
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<T> GetLastRecord<T>(long CorpID, string ObjectType, IEnumerable<long> ObjectIds) where T : Model.EtaBasicRealRecord
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            return ObjectIds.Select(x=>GetLastRecord<T>(CorpID,ObjectType,x)).Where(x => x != null).ToList();   
        }

        /// <summary>
        /// 获取最后一条记录
        /// </summary>
        public List<T> GetLastRecord<T>(long CorpID, IEnumerable<KeyValuePair<string,long>> list) where T : Model.EtaBasicRealRecord
        {
            if (list == null || list.Count() < 1)
                return default;
            return list.Select(x => GetLastRecord<T>(CorpID, x.Key, x.Value)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public T GetLastNormalRecord<T>(long CorpID, string ObjectType, long ObjectID) where T : Model.EtaBasicRealRecord
        {
            var redisKey = CreateRedisKey(CorpID, ObjectType, ObjectID);
            return _redisClient.HashGetJson<T>(redisKey, _lastNormalRecord);
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<T> GetLastNormalRecord<T>(long CorpID, string ObjectType, IEnumerable<long> ObjectIds) where T : Model.EtaBasicRealRecord
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            return ObjectIds.Select(x => GetLastNormalRecord<T>(CorpID, ObjectType, x)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条正常记录
        /// </summary>
        public List<T> GetLastNormalRecord<T>(long CorpID, IEnumerable<KeyValuePair<string, long>> list) where T : Model.EtaBasicRealRecord
        {
            if (list == null || list.Count() < 1)
                return default;
            return list.Select(x => GetLastNormalRecord<T>(CorpID, x.Key, x.Value)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public T GetLastAbnormalRecord<T>(long CorpID, string ObjectType, long ObjectID) where T : Model.EtaBasicRealRecord
        {
            var redisKey = CreateRedisKey(CorpID, ObjectType, ObjectID);
            return _redisClient.HashGetJson<T>(redisKey, _lastAbnormalRecord);
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<T> GetLastAbnormalRecord<T>(long CorpID, string ObjectType, IEnumerable<long> ObjectIds) where T : Model.EtaBasicRealRecord
        {
            if (ObjectIds == null || ObjectIds.Count() < 1)
                return default;
            return ObjectIds.Select(x => GetLastAbnormalRecord<T>(CorpID, ObjectType, x)).Where(x => x != null).ToList();
        }

        /// <summary>
        /// 获取最后一条不正常记录
        /// </summary>
        public List<T> GetLastAbnormalRecord<T>(long CorpID, IEnumerable<KeyValuePair<string, long>> list) where T : Model.EtaBasicRealRecord
        {
            if (list == null || list.Count() < 1)
                return default;
            return list.Select(x => GetLastAbnormalRecord<T>(CorpID, x.Key, x.Value)).Where(x => x != null).ToList();
        }


        #endregion




    }
}