using BaseOUDAL;
using System.Collections;
using YieldChain.Commons;
using YLErp.Abstract;
using YLErp.Model;

namespace YLErp.Modules.DataCacheModule
{
    /// <summary>
    /// 数据缓存管理静态类(提供基础数据缓存及跟踪数据更新事件)
    /// </summary>
    public static partial class DataCacheManager
    {
        const int MaxTimeOut = 2 * 60 * 1000;

        static DateTime _lastTime;
        static readonly IYcLogger _logger;
        static readonly Timer _updateTimer;
        static readonly ThrottleAction _throttleValueDate;
        static readonly TimeSpan[] MarketPriceTimes;
        static readonly YLDBDataCacheUpdater _yLDBDataUpdater;
        static readonly ClientDBDataCacheUpdater _clientDBDataUpdater;

        static DataCacheManager()
        {
            _updateTimer = new Timer(TimerTask, null, 1000, Interval);

            _throttleValueDate = new ThrottleAction(() => BLL.valuedateBLL.ResetValueDate(), 30);

            _yLDBDataUpdater = new YLDBDataCacheUpdater();

            _clientDBDataUpdater = new ClientDBDataCacheUpdater();

            _logger = LogFactory.GetLogger(nameof(DataCacheManager));

            DebugOut = AppContext.TryGetSwitch("AppSettings:DataCacheDebug", out _);

            MarketPriceTimes = new TimeSpan[] {
                 new TimeSpan(3,0,0),new TimeSpan(8,30,0),
                 new TimeSpan(15,30,0),new TimeSpan(20,30,0)
            };
        }

        /// <summary>
        /// 当前最大traceID
        /// </summary>
        public static long MaxId => _yLDBDataUpdater.MaxId;

        /// <summary>
        /// 轮询间隔
        /// </summary>
        public static int Interval { get; private set; } = 2000;

        /// <summary>
        /// 调试日志是否输出
        /// </summary>
        public static bool DebugOut { get; set; }

        /// <summary>
        /// 这个方法在WEB项目IRegisteredObject接口中调用非常关键，
        /// 可以有效避免定时更新被dispose掉
        /// </summary>
        public static void StartUpdate(int interval = 2000)
        {
            if (interval > 2000)
            {
                Interval = interval;
            }
            _updateTimer.Change(0, Interval);
        }

        /// <summary>
        /// 
        /// </summary>
        public static void StopUpdate()
        {
            _updateTimer?.Change(Timeout.Infinite, 0);
        }

        /// <summary>
        /// 更新一次
        /// </summary>
        public static void UpdateOnce()
        {
            TimerTask(null);
        }

        /// <summary>
        /// 注册数据跟踪监听器(暂时只支持ylcms数据库)
        /// </summary>
        public static void RegisterDataTraceSink(IDataTraceSink sink)
        {
            _yLDBDataUpdater.RegisterDataTraceSink(sink);
        }

        /// <summary>
        /// 取消数据跟踪监听器注册(暂时只支持ylcms数据库)
        /// </summary>
        public static void UnRegisterDataTraceSink(IDataTraceSink sink)
        {
            _yLDBDataUpdater.UnRegisterDataTraceSink(sink);
        }

        public static void ResetDataCache()
        {
            _yLDBDataUpdater.ResetDataCache();
            _clientDBDataUpdater.ResetDataCache();
        }

        /// <summary>
        /// 定时调用缓存更新操作
        /// </summary>
        private static void TimerTask(object state)
        {
            try
            {
                _updateTimer.Change(MaxTimeOut, MaxTimeOut);

                //控制基础数据更新在10s的频率上
                if (_lastTime.AddSeconds(10) < DateTime.Now)
                {
                    _lastTime = DateTime.Now;
                    _yLDBDataUpdater.Update();
                    _clientDBDataUpdater.Update();
                }

                //更新标的价格
                try
                {
                    var delay = false;
                    var time = DateTime.Now.TimeOfDay;
                    for (var i = 0; i < MarketPriceTimes.Length; i += 2)
                    {
                        delay = time > MarketPriceTimes[i] && time < MarketPriceTimes[i + 1];
                        if (delay)
                        {
                            break;
                        }
                    }

                    if (GetUnderlyingDataSource().UpdatePrices(delay) && DebugOut)
                    {
                        _logger.Debug("更新标的价格");
                    }
                }
                catch (Exception ex)
                {
                    _logger.Error(ex, "更新标的价格出错");
                }

                _throttleValueDate.Execute();
            }
            catch (Exception ex)
            {
                _logger.Error(ex, "TimerTask");
            }
            finally
            {
                _updateTimer.Change(Interval, Interval);
            }
        }

        #region-----缓存的基础数据源------

        /// <summary>
        /// 交易品种
        /// </summary>
        public static IDataSourceKey2<Variety> GetVarietyDataSource()
        {
            return VarietyDataSource.Default;
        }

        /// <summary>
        /// 期权标的
        /// </summary>
        public static IUnderlyingDataSource GetUnderlyingDataSource()
        {
            return new UnderlyingDbDataSource();
        }

        /// <summary>
        /// 场内期权基础数据
        /// </summary>
        public static IDataSourceKey2<ExchangeListOption> GetExchangeListOptionDataSource()
        {
            return ExchangeListOptionDataSource.Default;
        }

        /// <summary>
        /// 标的相关性
        /// </summary>
        public static IDataSource<CorrelationTable> GetCorrelationDataSource()
        {
            return CorrelationDataSource.Default;
        }

        /// <summary>
        /// 个股黑白名单
        /// </summary>
        public static IDataSource<StockBlackWhite> GetStockBlackWhiteDataSource()
        {
            return StockBlackWhiteDataSource.Default;
        }

        /// <summary>
        /// 股票手续费设定
        /// </summary>
        public static IDataSource<StockCommissionConfig> GetStockCommissionDataSource()
        {
            return StockCommissionDataSource.Default;
        }

        /// <summary>
        /// 对冲账户
        /// </summary>
        public static IDataSource<ExchangeAccount> GetExchangeAccountDataSource()
        {
            return ExchangeAccountDataSource.Default;
        }

        /// <summary>
        /// 簿记账户
        /// </summary>
        public static IDataSource<AssetUnit> GetAssetUnitDataSource()
        {
            return AssetUnitDataSource.Default;
        }

        /// <summary>
        /// 簿记账户组
        /// </summary>
        public static IDataSource<AssetUnitGroup> GetAssetUnitGroupDataSource()
        {
            return AssetUnitDataGroupSource.Default;
        }

        /// <summary>
        /// 客户黑名单
        /// </summary>
        public static IDataSource<client_black> GetClientBlackDataSource()
        {
            return ClientBlackDataSource.Default;
        }

        /// <summary>
        /// 客户信息
        /// </summary>
        public static IDataSource<Client> GetClientDataSource()
        {
            return ClientDataSource.Default;
        }

        /// <summary>
        /// 客户等级信息
        /// </summary>
        public static IDataSource<ClientLevel> GetClientLevelDataSource()
        {
            return ClientLevelDataSource.Default;
        }

        /// <summary>
        /// 市场信息
        /// </summary>
        public static IDataSource<Market> GetMarketDataSource()
        {
            return MarketDataSource.Default;
        }

        #endregion

        #region----用于缓存数据调试----

        public static List<string> GetSinkTables()
        {
            var tableNames = new List<string>(30);
            _yLDBDataUpdater.GetSinkTables(tableNames);
            _clientDBDataUpdater.GetSinkTables(tableNames);
            return tableNames;
        }

        public static string GetSinkData(string tableName)
        {
            if (string.IsNullOrEmpty(tableName))
            {
                return "tableName参数不能为空";
            }

            var str = _yLDBDataUpdater.GetSinkData(tableName);

            if (str.StartsWith("未找到数据"))
            {
                str = _clientDBDataUpdater.GetSinkData(tableName);
            }

            return str;
        }

        #endregion

        #region----DataUpdater----

        abstract class DataCacheUpdaterBase
        {
            //初始值设置为-1支持datatrace表数据空的情况
            public long MaxId { get; private set; } = -1;

            protected List<IDataTraceSink> SinkList { get; set; }

            /// <summary>
            /// 更新跟踪数据
            /// </summary>
            protected void InnerUpdate(DataTraceDbContext dbContext, string dbName)
            {
                var maxid = MaxId;

                try
                {
                    if (MaxId < 0)
                    {
                        MaxId = dbContext.DataTrace.Max(n => (long?)n.id) ?? 0;
                    }
                    else
                    {
                        var query = from a in dbContext.DataTrace
                                    where a.id > MaxId
                                    orderby a.id
                                    select new DataTraceInfo
                                    {
                                        id = a.id,
                                        TableName = a.TableName,
                                        DataKeyId = a.DataKeyId
                                    };

                        var traceDatas = query.ToArray();

                        if (traceDatas.Length > 0)
                        {
                            MaxId = traceDatas[traceDatas.Length - 1].id;

                            var set = new HashSet<string>(traceDatas.Length, StringComparer.OrdinalIgnoreCase);

                            foreach (var data in traceDatas)
                            {
                                var key = string.Concat(data.TableName, "[|]", data.DataKeyId);

                                if (set.Add(key))
                                {
                                    try
                                    {
                                        lock (SinkList)
                                        {
                                            foreach (var sink in SinkList)
                                            {
                                                sink.OnDataTrace(data);
                                            }
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        _logger.Error(ex, "UpdateTraceData");
                                    }
                                }
                            }
                        }
                    }

                    if (MaxId == maxid)
                    {
                        return;
                    }

                    if (DebugOut)
                    {
                        _logger.Debug($"[{dbName}.Datatrace MaxId]{MaxId}");
                    }
                }
                catch (Exception ex)
                {
                    _logger.Error(ex, dbName + ".Datatrace更新出错");
                }

                try
                {
                    lock (SinkList)
                    {
                        foreach (var sink in SinkList)
                        {
                            sink.UpdateCache();
                        }
                    }
                }
                catch (Exception ex)
                {
                    MaxId = -1;
                    _logger.Error(ex, dbName + ".Datatrace缓存更新出错");
                }
            }

            /// <summary>
            /// 注册数据跟踪监听器
            /// </summary>
            public void RegisterDataTraceSink(IDataTraceSink sink)
            {
                if (sink == null)
                {
                    throw new ArgumentNullException(nameof(sink));
                }

                lock (SinkList)
                {
                    if (!SinkList.Contains(sink))
                    {
                        SinkList.Add(sink);
                    }
                }
            }

            /// <summary>
            /// 取消数据跟踪监听器注册
            /// </summary>
            public void UnRegisterDataTraceSink(IDataTraceSink sink)
            {
                if (sink != null)
                {
                    lock (SinkList)
                    {
                        SinkList.Remove(sink);
                    }
                }
            }

            /// <summary>
            /// 重置数据缓存
            /// </summary>
            public void ResetDataCache()
            {
                MaxId = -1;

                foreach (var sink in SinkList)
                {
                    sink.Reset();
                }
            }

            public void GetSinkTables(List<string> resultList)
            {
                foreach (var sink in SinkList)
                {
                    if (sink is DataTraceSink ds)
                    {
                        resultList.Add(ds.TableName);
                    }
                    else if (sink is DataTraceSinkGroup dsg)
                    {
                        resultList.AddRange(dsg.AsEnumerable().Select(n => n.TableName));
                    }
                    else
                    {
                        resultList.Add("unknown table sink");
                    }
                }
            }

            public string GetSinkData(string tableName)
            {
                if (string.IsNullOrEmpty(tableName))
                {
                    return "tableName参数不能为空";
                }

                foreach (var sink in SinkList)
                {
                    if (sink is DataTraceSink ds)
                    {
                        if (ds.TableName == tableName)
                        {
                            return (ds.Updater as IJsonSerializable)?.ToJson() ?? "未实现JSON序列化接口:" + tableName;
                        }
                    }
                    else if (sink is DataTraceSinkGroup dsg)
                    {
                        foreach (var sink2 in dsg)
                        {
                            if (sink2.TableName == tableName)
                            {
                                return (sink2.Updater as IJsonSerializable)?.ToJson() ?? "未实现JSON序列化接口:" + tableName;
                            }
                        }
                    }
                }

                return "未找到数据更新容器:" + tableName;
            }
        }

        class YLDBDataCacheUpdater : DataCacheUpdaterBase
        {
            public YLDBDataCacheUpdater()
            {
                var basicDataUpdaters = new List<IDataUpdater>() {
                    (IDataUpdater)GetMarketDataSource(),
                    (IDataUpdater)GetVarietyDataSource(),
                    (IDataUpdater)GetCorrelationDataSource(),
                    (IDataUpdater)GetUnderlyingDataSource(),
                    (IDataUpdater)GetExchangeListOptionDataSource(),
                    (IDataUpdater)GetStockBlackWhiteDataSource(),
                    (IDataUpdater)GetClientBlackDataSource(),
                    (IDataUpdater)GetStockCommissionDataSource(),
                    (IDataUpdater)GetExchangeAccountDataSource(),
                    (IDataUpdater)GetAssetUnitDataSource(),
                    (IDataUpdater)GetAssetUnitGroupDataSource()
                };

                if (AppManager.SubSystem != Enums.SubSystemName.OtcWeb)
                {
                    basicDataUpdaters.Insert(0, AppConfigUpdater.Default);
                }

                //基础数据6秒刷新
                var baseDataTrace = new DataTraceSinkGroup(6, basicDataUpdaters.ToArray());

                SinkList = new List<IDataTraceSink>() { baseDataTrace };

                //设置基础数据更新时间
                var handler = new EventHandler((object sender, EventArgs e) =>
                {
                    Events.EventBus.Publish<Events.DataCacheUpdateEvent>();
                });

                foreach (var item in basicDataUpdaters)
                {
                    if (item is IDataSourceEvent dataSourceEvent)
                    {
                        dataSourceEvent.DataSourceUpdated += handler;
                    }
                }
            }

            public void Update()
            {
                using (var dbtrace = DbContextFactory.GetYLDbContext().GetDataTraceDbContext())
                {
                    InnerUpdate(dbtrace, "ylcmsDB");
                }
            }
        }

        class ClientDBDataCacheUpdater : DataCacheUpdaterBase
        {
            public ClientDBDataCacheUpdater()
            {
                var basicDataUpdaters = new List<IDataUpdater>() {
                    (IDataUpdater)GetClientDataSource(),
                    (IDataUpdater)GetClientLevelDataSource(),
                    (IDataUpdater)GetClientBlackDataSource()
                };

                //基础数据6秒刷新
                var baseDataTrace = new DataTraceSinkGroup(6, basicDataUpdaters.ToArray());

                SinkList = new List<IDataTraceSink>() { baseDataTrace };

                //设置基础数据更新时间
                var handler = new EventHandler((object sender, EventArgs e) =>
                {
                    Events.EventBus.Publish<Events.DataCacheUpdateEvent>();
                });

                foreach (var item in basicDataUpdaters)
                {
                    if (item is IDataSourceEvent dataSourceEvent)
                    {
                        dataSourceEvent.DataSourceUpdated += handler;
                    }
                }
            }

            public void Update()
            {
                using (var dbtrace = DbContextFactory.GetClientDbContext(null).GetDataTraceDbContext())
                {
                    InnerUpdate(dbtrace, "clientDB");
                }
            }
        }

        #endregion
    }

    /// <summary>
    /// 数据跟踪监听接口
    /// </summary>
    public interface IDataTraceSink
    {
        void Reset();

        void UpdateCache();

        void OnDataTrace(DataTraceInfo dataTrace);
    }

    /// <summary>
    /// 数据跟踪监听类库
    /// </summary>
    public class DataTraceSink : IDataTraceSink
    {
        readonly List<string> _list;
        readonly ThrottleAction _throttle;

        /// <summary>
        /// 构造函数--不使用throttle更新方式
        /// </summary>
        public DataTraceSink(IDataUpdater dataUpdater)
        {
            _list = new List<string> { "0" };
            Updater = dataUpdater ?? throw new ArgumentNullException(nameof(dataUpdater));
        }

        /// <summary>
        /// 构造函数--使用throttle更新方式
        /// </summary>
        public DataTraceSink(int throttleUpdateWaitSeconds, IDataUpdater dataUpdater) : this(dataUpdater)
        {
            _throttle = new ThrottleAction(DoUpdateCache, throttleUpdateWaitSeconds < 1 ? 2 : throttleUpdateWaitSeconds, 60);
        }

        public void Reset()
        {
            if (Updater is IDataSource dataSource)
            {
                dataSource.ResetDataSource();
            }

            _list.Add("0");
        }

        public void OnDataTrace(DataTraceInfo dataTrace)
        {
            if (dataTrace != null && Updater.TableName.Equals(dataTrace.TableName, StringComparison.OrdinalIgnoreCase))
            {
                lock (_list)
                {
                    _list.Add(dataTrace.DataKeyId);
                }
            }
        }

        /// <summary>
        /// 更新数据
        /// </summary>
        public void UpdateCache()
        {
            if (_throttle != null)
            {
                _throttle.Execute();
            }
            else
            {
                DoUpdateCache();
            }
        }

        private void DoUpdateCache()
        {
            string[] idArr = null;

            try
            {
                lock (_list)
                {
                    if (_list.Count < 1)
                    {
                        return;
                    }
                    idArr = _list.ToArray();

                    _list.Clear();
                }

                AppManager.SetSysInfo("[DataTrace]" + Updater.TableName, "执行,top10-Id:" + string.Join(",", idArr.Take(10)));

                Updater.UpdateData(idArr);
            }
            catch (Exception ex)
            {
                if (idArr != null && idArr.Length > 0)
                {
                    lock (_list)
                    {
                        _list.AddRange(idArr);
                    }
                }

                LogFactory.GetLogger("DataTrace_" + Updater.TableName).Error(ex, "更新缓存失败");
            }
        }

        public IDataUpdater Updater { get; }

        /// <summary>
        /// 
        /// </summary>
        public string TableName => Updater.TableName;
    }

    /// <summary>
    /// 
    /// </summary>
    public class DataTraceSinkGroup : IDataTraceSink, IEnumerable<DataTraceSink>
    {
        readonly ThrottleAction _throttle;
        readonly IEnumerable<DataTraceSink> _sinks;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="updaters">更新器集合</param>
        /// <param name="throttleUpdateWaitSeconds">每次更新等待的时间(秒)</param>
        public DataTraceSinkGroup(int throttleUpdateWaitSeconds, params IDataUpdater[] updaters)
        {
            if (updaters == null)
            {
                throw new ArgumentNullException(nameof(updaters));
            }
            _throttle = new ThrottleAction(ThrottleUpdate, throttleUpdateWaitSeconds < 1 ? 2 : throttleUpdateWaitSeconds, 60);
            _sinks = updaters.Where(n => !string.IsNullOrEmpty(n?.TableName)).Select(n => new DataTraceSink(n)).ToArray();
        }

        public void Reset()
        {
            foreach (var sink in _sinks)
            {
                sink.Reset();
            }
        }

        /// <summary>
        /// Throttle机制的更新行为调用方法
        /// </summary>
        private void ThrottleUpdate()
        {
            foreach (var sink in _sinks)
            {
                sink.UpdateCache();
            }
        }

        /// <summary>
        /// 更新缓存数据(采用了Throttle机制)
        /// </summary>
        public void UpdateCache()
        {
            _throttle.Execute();
        }

        /// <summary>
        /// 
        /// </summary>
        public void OnDataTrace(DataTraceInfo dataTrace)
        {
            foreach (var sink in _sinks)
            {
                sink.OnDataTrace(dataTrace);
            }
        }

        public IEnumerator<DataTraceSink> GetEnumerator()
        {
            return _sinks.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _sinks.GetEnumerator();
        }
    }
}