using System.Data;
using YLErp.Models;

namespace YLErp.Modules.MarginModule
{
    /// <summary>
    /// 标的预付金计算参数数据提供服务
    /// </summary>
    public class MarginParamProvider : YLBaseService
    {
        readonly DateTime _date;
        readonly VarietyMarginParamProvider _vProvider;
        readonly Dictionary<string, MarginParamModelEx> _dic;

        public MarginParamProvider(OptUserInfo userInfo, DateTime valueDate) : base(userInfo)
        {
            _date = valueDate;
            _vProvider = new VarietyMarginParamProvider(userInfo, valueDate);
            _dic = new Dictionary<string, MarginParamModelEx>(StringComparer.OrdinalIgnoreCase);
        }

        /// <summary>
        /// 是否已经初始化
        /// </summary>
        public bool Initialized => _dic != null && _dic.Count > 0;

        #region-----初始化数据----

        /// <summary>
        /// 初始化数据提供,非必需操作
        /// </summary>
        public MarginParamProvider Initialize(HashSet<string> underlyingCodes, MarginParamTypeEnum typeEnum)
        {
            if (underlyingCodes is null || typeEnum == MarginParamTypeEnum.None || !underlyingCodes.Any(n => !string.IsNullOrEmpty(n)))
            {
                return this;
            }

            if (_dic.Count > 0)
            {
                throw new Exception("只允许初始化一次");
            }

            underlyingCodes.Remove(null);

            var udatas = DbContext.underlying_manager.Where(n => underlyingCodes.Contains(n.UnderlyingCode))
                .Select(n => new
                {
                    n.UnderlyingCode,
                    VarietyId = n.CommodityCode == "组合标的" || n.CommodityCode == "篮子标的" ? 0 : n.UnderlyingTypeId
                }).ToDictionary(n => n.UnderlyingCode, m => m.VarietyId, StringComparer.OrdinalIgnoreCase);

            var removeList = new List<string>();
            foreach (var code in underlyingCodes)
            {
                var mp = new MarginParamModelEx { TypeEnum = typeEnum, VaTypeEnum = typeEnum };

                if (udatas.TryGetValue(code, out var vid))
                {
                    mp.VarietyId = vid;
                }
                else
                {
                    //标的代码在数据库中不存在
                    removeList.Add(code);
                    mp.MarginRate = mp.VolatilityRate = mp.UpDownLimit = mp.VarietyId = 0;
                }

                _dic[code] = mp;
            }

            underlyingCodes.RemoveWhere(O => removeList.Contains(O));

            var enums = new[] { MarginParamTypeEnum.MarginRate, MarginParamTypeEnum.UpDownLimit, MarginParamTypeEnum.VolatilityRate };

            foreach (var enm in enums)
            {
                if ((typeEnum & enm) == enm)
                {
                    InnerInitializeUnderlying(underlyingCodes, enm);
                }
            }

            return this;
        }

        //用于初始化标的预付金参数数据
        private void InnerInitializeUnderlying(IEnumerable<string> underlyingCodes, MarginParamTypeEnum typeEnum)
        {
            var valueType = GetValueType(typeEnum);

            var predicat = PredicateBuilder.Create<UnderlyingHisData>(uh => underlyingCodes.Contains(uh.UnderlyingCode)
                                    && uh.ValueDate <= _date && uh.ValueType == valueType);

            var ugQuery = from uh in DbContext.UnderlyingHisData.Where(predicat)
                          group uh by uh.UnderlyingCode into g
                          select new { UnderlyingCode = g.Key, ValueDate = g.Max(n => n.ValueDate) };

            var uhQuery = from uh in DbContext.UnderlyingHisData.Where(predicat)
                          join ug in ugQuery on new { uh.UnderlyingCode, uh.ValueDate } equals new { ug.UnderlyingCode, ug.ValueDate }
                          select new
                          {
                              uh.UnderlyingCode,
                              uh.Value,
                              uh.ValueFlag
                          };

            var datas = uhQuery.ToArray();

            switch (typeEnum)
            {
                case MarginParamTypeEnum.MarginRate:
                    foreach (var data in datas)
                    {
                        _dic[data.UnderlyingCode].MarginRate = data.ValueFlag == "N" ? (double?)null : data.Value;
                    }
                    break;
                case MarginParamTypeEnum.UpDownLimit:
                    foreach (var data in datas)
                    {
                        _dic[data.UnderlyingCode].UpDownLimit = data.ValueFlag == "N" ? (double?)null : data.Value;
                        _dic[data.UnderlyingCode].IsUpDownLimitFixed = data.ValueFlag != "%";
                    }
                    break;
                case MarginParamTypeEnum.VolatilityRate:
                    foreach (var data in datas)
                    {
                        _dic[data.UnderlyingCode].VolatilityRate = data.ValueFlag == "N" ? (double?)null : data.Value;
                    }
                    break;
            }

            var unsetMps = _dic.Values.Where(n => !n.GetValue(typeEnum).HasValue).ToArray();
            var varietyIds = unsetMps.Select(n => n.VarietyId.Value).ToHashSet();
            _vProvider.Initialize(varietyIds, typeEnum);
            foreach (var item in unsetMps)
            {
                item.SetValue(typeEnum, _vProvider.GetData(item.VarietyId.Value, typeEnum));
            }
        }

        #endregion

        #region----获取预付金参数----

        /// <summary>
        /// 获取距valueDate最近的标的预付金率
        /// </summary>
        public double? GetMarginRate(string underlyingCode)
        {
            return GetData(underlyingCode, MarginParamTypeEnum.MarginRate);
        }

        /// <summary>
        /// 获取距valueDate最近的标的预付金率
        /// </summary>
        public bool TryGetMarginRate(string underlyingCode, out double marginRate)
        {
            return TryGetData(underlyingCode, MarginParamTypeEnum.MarginRate, out marginRate);
        }

        /// <summary>
        /// 获取距valueDate最近的标的涨跌幅度
        /// </summary>
        public bool TryGetUpdownLimit(string underlyingCode, out double upDownLimit, out bool isFixed)
        {
            if (TryGetData(underlyingCode, MarginParamTypeEnum.UpDownLimit, out upDownLimit))
            {
                isFixed = _dic[underlyingCode].IsUpDownLimitFixed;
                return true;
            }

            isFixed = false;
            upDownLimit = 0;
            return false;
        }

        /// <summary>
        /// 获取距valueDate最近的标的Span波动率变动
        /// </summary>
        public double? GetVolatilityRate(string underlyingCode)
        {
            return GetData(underlyingCode, MarginParamTypeEnum.VolatilityRate);
        }

        /// <summary>
        /// 获取距valueDate最近的标的Span波动率变动
        /// </summary>
        public bool TryGetVolatilityRate(string underlyingCode, out double volatilityRate)
        {
            return TryGetData(underlyingCode, MarginParamTypeEnum.VolatilityRate, out volatilityRate);
        }

        //获取特定预付金参数值
        private double? GetData(string underlyingCode, MarginParamTypeEnum typeEnum)
        {
            if (string.IsNullOrEmpty(underlyingCode))
            {
                return null;
            }

            //从字典中取数据

            if (_dic.TryGetValue(underlyingCode, out var mp) && (typeEnum & mp.TypeEnum) == typeEnum)
            {
                var dval = mp.GetValue(typeEnum);

                if (dval.HasValue || (typeEnum & mp.VaTypeEnum) == typeEnum)
                {
                    return dval;
                }
            }
            else
            {
                if (mp == null)
                {
                    _dic[underlyingCode] = mp = new MarginParamModelEx();
                }

                mp.TypeEnum |= typeEnum;

                //从underlying_hisdata表中取数据

                var valueType = GetValueType(typeEnum);
                var uhQuery = from uh in DbContext.UnderlyingHisData
                              where uh.UnderlyingCode == underlyingCode && uh.ValueDate <= _date && uh.ValueType == valueType
                              orderby uh.ValueDate descending
                              select new
                              {
                                  uh.Value,
                                  uh.ValueFlag
                              };

                var uhData = uhQuery.FirstOrDefault();

                if (uhData != null && uhData.ValueFlag != "N")
                {
                    mp.SetValue(typeEnum, uhData.Value);

                    if (typeEnum == MarginParamTypeEnum.UpDownLimit)
                    {
                        mp.IsUpDownLimitFixed = uhData.ValueFlag != "%";
                    }

                    return uhData.Value;
                }
                else if (!DbContext.UnderlyingHisData.Any(uh => uh.UnderlyingCode == underlyingCode && uh.ValueDate > _date && uh.ValueType == valueType && uh.ValueFlag != "N"))
                {
                    var un = DataCacheProvider.GetUnderlyingDataSource().GetData(underlyingCode);
                    switch (typeEnum)
                    {
                        case MarginParamTypeEnum.UpDownLimit:
                            if (NumberHelper.TryParse(un.UpDownLimit, out var pval, out var isPercent) && pval > 0)
                            {
                                mp.SetValue(typeEnum, pval);
                                mp.IsUpDownLimitFixed = !isPercent;
                                return pval;
                            }
                            break;
                        case MarginParamTypeEnum.VolatilityRate:
                            if (NumberHelper.TryParse(un.VolatilityRate, out pval, out isPercent) && pval > 0)
                            {
                                mp.SetValue(typeEnum, pval);
                                return pval;
                            }
                            break;
                        case MarginParamTypeEnum.MarginRate:
                            if (un.MarginRate.HasValue && un.MarginRate > 0)
                            {
                                mp.SetValue(typeEnum, pval = un.MarginRate.Value);
                                return pval;
                            }
                            break;
                    }
                }
            }

            //从variety_hisdata表中取数据

            mp.VaTypeEnum |= typeEnum;

            if (!mp.VarietyId.HasValue)
            {
                var un = DbContext.underlying_manager.Where(n => n.UnderlyingCode == underlyingCode)
                    .Select(n => new
                    {
                        n.CommodityCode,
                        n.UnderlyingTypeId
                    }).FirstOrDefault();

                mp.VarietyId = un == null || un.CommodityCode == "组合标的" || un.CommodityCode == "篮子标的" ? 0 : un.UnderlyingTypeId;
            }

            var dvalue = _vProvider.GetData(mp.VarietyId.Value, typeEnum);

            mp.SetValue(typeEnum, dvalue);

            return dvalue;
        }

        private bool TryGetData(string underlyingCode, MarginParamTypeEnum typeEnum, out double mpValue)
        {
            var dvalue = GetData(underlyingCode, typeEnum);
            mpValue = dvalue ?? 0;
            return dvalue.HasValue;
        }

        #endregion

        public double? GetVarietyData(int varietyId, MarginParamTypeEnum typeEnum)
        {
            return _vProvider.GetData(varietyId, typeEnum);
        }

        private static string GetValueType(MarginParamTypeEnum typeEnum)
        {
            switch (typeEnum)
            {
                case MarginParamTypeEnum.MarginRate:
                    return nameof(MarginParamModel.MarginRate);
                case MarginParamTypeEnum.UpDownLimit:
                    return nameof(MarginParamModel.UpDownLimit);
                case MarginParamTypeEnum.VolatilityRate:
                    return nameof(MarginParamModel.VolatilityRate);
                default: throw new NotSupportedException();
            }
        }
    }

    /// <summary>
    /// 品种级别的预付金参数提供
    /// </summary>
    public class VarietyMarginParamProvider : YLBaseService
    {
        readonly DateTime _date;
        readonly Dictionary<int, MarginParamModelEx> _dic;

        bool _hasInitAll;

        public VarietyMarginParamProvider(OptUserInfo userInfo, DateTime valueDate) : base(userInfo)
        {
            _date = valueDate;
            _dic = new Dictionary<int, MarginParamModelEx>();
        }

        #region----初始化----

        /// <summary>
        /// 初始化数据(非必需)
        /// </summary>
        public VarietyMarginParamProvider Initialize(MarginParamTypeEnum typeEnum)
        {
            IEnumerable<int> varietyIds;

            if (_hasInitAll)
            {
                varietyIds = _dic.Keys.ToArray();
            }
            else
            {
                _hasInitAll = true;
                varietyIds = DbContext.variety.Select(n => n.id).ToArray();
            }

            return InnerInitializeAllType(varietyIds, typeEnum);
        }

        /// <summary>
        /// 初始化数据(非必需)
        /// </summary>
        public VarietyMarginParamProvider Initialize(HashSet<int> varietyIds, MarginParamTypeEnum typeEnum)
        {
            return InnerInitializeAllType(varietyIds, typeEnum);
        }

        //typeEnum可以是多个并在一起的枚举值
        private VarietyMarginParamProvider InnerInitializeAllType(IEnumerable<int> varietyIds, MarginParamTypeEnum typeEnum)
        {
            var enums = new[] { MarginParamTypeEnum.MarginRate, MarginParamTypeEnum.UpDownLimit, MarginParamTypeEnum.VolatilityRate };

            foreach (var enm in enums)
            {
                if ((typeEnum & enm) == enm)
                {
                    InnerInitializeOneType(varietyIds, enm);
                }
            }

            return this;
        }

        //typeEnum只能是单个具体的枚举值
        private void InnerInitializeOneType(IEnumerable<int> varietyIds, MarginParamTypeEnum typeEnum)
        {
            if (varietyIds == null || !varietyIds.Any()) return;

            foreach (var vid in varietyIds)
            {
                if (!_dic.TryGetValue(vid, out var mp))
                {
                    _dic.Add(vid, mp = new MarginParamModelEx { VarietyId = vid });
                }
                mp.TypeEnum |= typeEnum;
            }

            var valueType = GetValueType(typeEnum);

            var baseQuery = DbContext.VarietyHisData.Where(vh => varietyIds.Contains(vh.VarietyId) && vh.ValueDate <= _date && vh.ValueType == valueType);

            var vgQuery = from vh in baseQuery
                          group vh by vh.VarietyId into g
                          select new { VarietyId = g.Key, ValueDate = g.Max(n => n.ValueDate) };

            var vhQuery = from vh in baseQuery
                          join vg in vgQuery on new { vh.VarietyId, vh.ValueDate } equals new { vg.VarietyId, vg.ValueDate }
                          select new { vh.VarietyId, vh.Value };

            var datas = vhQuery.ToArray();

            switch (typeEnum)
            {
                case MarginParamTypeEnum.MarginRate:
                    foreach (var data in datas)
                    {
                        _dic[data.VarietyId].MarginRate = data.Value;
                    }
                    break;
                case MarginParamTypeEnum.UpDownLimit:
                    foreach (var data in datas)
                    {
                        _dic[data.VarietyId].UpDownLimit = data.Value;
                    }
                    break;
                case MarginParamTypeEnum.VolatilityRate:
                    foreach (var data in datas)
                    {
                        _dic[data.VarietyId].VolatilityRate = data.Value;
                    }
                    break;
            }
        }

        #endregion

        #region----获取预付金参数----

        /// <summary>
        /// 获取距valueDate最近的品种预付金率
        /// </summary>
        public double? GetMarginRate(int varietyId)
        {
            return GetData(varietyId, MarginParamTypeEnum.MarginRate);
        }

        /// <summary>
        /// 获取距valueDate最近的品种预付金率
        /// </summary>
        public bool TryGetMarginRate(int varietyId, out double marginRate)
        {
            return TryGetData(varietyId, MarginParamTypeEnum.MarginRate, out marginRate);
        }

        /// <summary>
        /// 获取距valueDate最近的标的涨跌幅度
        /// </summary>
        public double? GetUpdownLimit(int varietyId)
        {
            return GetData(varietyId, MarginParamTypeEnum.UpDownLimit);
        }

        /// <summary>
        /// 获取距valueDate最近的标的涨跌幅度
        /// </summary>
        public bool TryGetUpdownLimit(int varietyId, out double upDownLimit)
        {
            return TryGetData(varietyId, MarginParamTypeEnum.UpDownLimit, out upDownLimit);
        }

        /// <summary>
        /// 获取距valueDate最近的标的Span波动率变动
        /// </summary>
        public double? GetVolatilityRate(int varietyId)
        {
            return GetData(varietyId, MarginParamTypeEnum.VolatilityRate);
        }

        /// <summary>
        /// 获取距valueDate最近的标的Span波动率变动
        /// </summary>
        public bool GetVolatilityRate(int varietyId, out double volatilityRate)
        {
            return TryGetData(varietyId, MarginParamTypeEnum.VolatilityRate, out volatilityRate);
        }

        /// <summary>
        /// 
        /// </summary>
        public double? GetData(int varietyId, MarginParamTypeEnum typeEnum)
        {
            if (varietyId < 1) return null;

            if (_dic.TryGetValue(varietyId, out var mp) && (mp.TypeEnum & typeEnum) == typeEnum)
            {
                return mp.GetValue(typeEnum);
            }

            if (mp == null)
            {
                _dic[varietyId] = mp = new MarginParamModelEx { VarietyId = varietyId };
            }

            var valueType = GetValueType(typeEnum);

            var hquery = from h in DbContext.VarietyHisData
                         where h.VarietyId == varietyId && h.ValueDate <= _date && h.ValueType == valueType
                         orderby h.ValueDate descending
                         select (double?)h.Value;

            var mpValue = hquery.FirstOrDefault();

            if (mpValue == null)
            {
                var va = DataCacheProvider.GetVarietyDataSource().GetData(varietyId);
                if (va != null)
                {
                    switch (typeEnum)
                    {
                        case MarginParamTypeEnum.MarginRate:
                            mpValue = va.Margin;
                            break;
                        case MarginParamTypeEnum.UpDownLimit:
                            mpValue = va.UpLimitValue;
                            break;
                        case MarginParamTypeEnum.VolatilityRate:
                            mpValue = va.VolatilityRateValue;
                            break;
                    }
                }
            }

            mp.SetValue(typeEnum, mpValue ?? 0);

            return mpValue;
        }

        /// <summary>
        /// 
        /// </summary>
        public bool TryGetData(int varietyId, MarginParamTypeEnum typeEnum, out double mpValue)
        {
            var dvalue = GetData(varietyId, typeEnum);
            mpValue = dvalue ?? 0;
            return dvalue.HasValue;
        }

        #endregion

        private static string GetValueType(MarginParamTypeEnum typeEnum)
        {
            switch (typeEnum)
            {
                case MarginParamTypeEnum.MarginRate:
                    return nameof(MarginParamModel.MarginRate);
                case MarginParamTypeEnum.UpDownLimit:
                    return nameof(MarginParamModel.UpDownLimit);
                case MarginParamTypeEnum.VolatilityRate:
                    return nameof(MarginParamModel.VolatilityRate);
                default: throw new NotSupportedException();
            }
        }
    }

    /// <summary>
    /// 
    /// </summary>
    class MarginParamModelEx : MarginParamModel
    {
        public int? VarietyId;

        /// <summary>
        /// 用于检查是否已经向数据库请求过
        /// </summary>
        public MarginParamTypeEnum TypeEnum { get; set; }

        /// <summary>
        /// 用于检查是否已经从数据库请求过品种关联的数据
        /// </summary>
        public MarginParamTypeEnum VaTypeEnum { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public double? GetValue(MarginParamTypeEnum typeEnum)
        {
            switch (typeEnum)
            {
                case MarginParamTypeEnum.MarginRate:
                    return MarginRate;
                case MarginParamTypeEnum.UpDownLimit:
                    return UpDownLimit;
                case MarginParamTypeEnum.VolatilityRate:
                    return VolatilityRate;
                default: throw new NotSupportedException();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public void SetValue(MarginParamTypeEnum typeEnum, double? dvalue)
        {
            if (dvalue.HasValue)
            {
                dvalue = Math.Abs(dvalue.Value);
            }

            switch (typeEnum)
            {
                case MarginParamTypeEnum.MarginRate:
                    MarginRate = dvalue;
                    break;
                case MarginParamTypeEnum.UpDownLimit:
                    UpDownLimit = dvalue;
                    break;
                case MarginParamTypeEnum.VolatilityRate:
                    VolatilityRate = dvalue;
                    break;
                default: throw new NotSupportedException();
            }
        }
    }

    /// <summary>
    /// 预付金参数类型枚举
    /// </summary>
    [Flags]
    public enum MarginParamTypeEnum
    {
        None = 0,
        //Span波动率变动
        MarginRate = 1 << 0,
        //Span涨跌幅度
        UpDownLimit = 1 << 1,
        //预付金比例
        VolatilityRate = 1 << 2,

        All = MarginRate | UpDownLimit | VolatilityRate
    }
}