using BaseOUDAL;
using System.Linq.Expressions;
using System.Text.RegularExpressions;
using YLErp.Model;
using YLErp.Modules;
using YLErp.Modules.DicForTranslationModule;
using YLErp.Modules.UnderlyingModule;

namespace YLErp.BLL
{
    public class underlying_managerBLL
    {
        private readonly YLContext db = new YLContext();

        public static IQueryable<underlying_manager> GetQuery()
        {
            return new YLContext().underlying_manager.AsNoTracking();
        }

        public static underlying_manager GetById(int id)
        {
            return DataCacheProvider.GetUnderlyingDataSource().GetData(id);
        }

        public static underlying_manager GetByCode(string underlyingCode)
        {
            return DataCacheProvider.GetUnderlyingDataSource().GetData(underlyingCode);
        }

        /// <summary>
        /// 获取标的涨停幅度(OTC-8856重构)
        /// </summary>
        public static double GetUpLimit(string underlyingCode)
        {
            var underlying = DataCacheProvider.GetUnderlyingDataSource().GetData(underlyingCode);
            return underlying == null ? 0 : DataCacheProvider.GetVarietyDataSource().GetData(underlying.UnderlyingTypeId)?.UpLimitValue ?? 0;
        }

        public static List<underlying_manager> GetUnderlyingManagerByVarieties(List<Variety> varieties)
        {
            if (varieties == null || varieties.Count == 0)
            {
                return new List<underlying_manager>();
            }

            var varietyIds = varieties.Select(x => x.id).ToList();
            return GetQuery().Where(x => varietyIds.Contains(x.UnderlyingTypeId)).ToList();
        }

        /// <summary>
        /// 是否有色金属(特定情况下可以使用汉语拼音)
        /// </summary>
        public static bool IsYouSeJinShu(string underlyingcode)
        {
            if (string.IsNullOrWhiteSpace(underlyingcode))
            {
                return false;
            }
            underlyingcode = underlyingcode.TrimStart();
            if (underlyingcode.Length < 2)
            {
                return false;
            }

            var arr = new[] { "AL", "CU", "ZN", "NI" };
            return arr.Contains(underlyingcode.Substring(0, 2).ToUpperInvariant());
        }

        public static List<underlying_manager> GetAllLiveunderlying_managerModel()
        {
            return GetQuery().Where(u => u.UnderlyingState != "Matured" && u.LaunchState == "1").ToList();
        }

        /// <summary>
        /// 
        /// </summary>
        public static void MergeUnderlyingFromTrade(underlying_manager underlying, OtcTradeBase trade)
        {
            //临时设置underlying
            underlying.id = trade.UnderlyingId;
            underlying.UnderlyingCode = trade.UnderlyingCode;
            underlying.UnderlyingInstrumentType = trade.UnderlyingInstrumentType;
            underlying.Price = trade.SpotPrice;
            if (underlying.QuotationDate == null)
            {
                underlying.QuotationDate = trade.TradeDate;
            }
        }

        /// <summary>
        /// 获取某个underlying的最新价格
        /// </summary>
        public static double GetUnderlyingPrice(int id)
        {
            using (var db = new YLContext())
            {
                var um = db.underlying_manager.Where(x => x.id == id)
                    .Select(n => new { n.Price, n.CommodityCode, n.UnderlyingCode }).FirstOrDefault();

                if (um == null)
                {
                    return 0;
                }

                if (um.CommodityCode == "组合标的")
                {
                    return new SyntheticUnderlyingPriceService(OptUserInfo.SystemUser).GetPrice(um.UnderlyingCode) ?? 0;
                }

                return um.Price ?? 0;
            }
        }

        /// <summary>
        /// 获取所有股票标的
        /// </summary>
        public static List<underlying_manager> GetAllStockModel()
        {
            return GetQuery().Where(u => u.UnderlyingInstrumentType == "Stock").ToList();
        }

        /// <summary>
        /// 如：rb1893 获取为RB,规则获取最初的非数字头
        /// </summary>
        public static string GetCommodityCodeByUnCode(string underlyingCode)
        {
            var re = new Regex("^[a-zA-Z]");
            return re.Match(underlyingCode).Groups[0].Value;
        }

        public underlying_manager UpdateSingle(int id, UnderlyingManagerReq data)
        {
            var model = db.underlying_manager.Find(id);
            Setunderlying_manager(model, data);
            db.SaveChanges();
            return model;
        }

        /// <summary>
        /// 设置model，如果不为空就设置,如果为空则和之前一样
        /// </summary>
        public underlying_manager Setunderlying_manager(underlying_manager model, UnderlyingManagerReq data)
        {
            if (!string.IsNullOrEmpty(data.LaunchState))
            {
                model.LaunchState = data.LaunchState;
            }

            if (!string.IsNullOrEmpty(data.MarketName))
            {
                model.MarketName = data.MarketName;
            }

            if (!string.IsNullOrEmpty(data.UnderlyingName))
            {
                model.UnderlyingName = data.UnderlyingName;
            }

            if (!string.IsNullOrEmpty(data.UnderlyingCode))
            {
                model.UnderlyingCode = data.UnderlyingCode;
            }

            if (!string.IsNullOrEmpty(data.UnderlyingType))
            {
                model.UnderlyingType = data.UnderlyingType;
            }

            if (data.MaturityDate != null && data.MaturityDate != DateTime.MinValue)
            {
                model.MaturityDate = data.MaturityDate.Value;
            }

            if (!string.IsNullOrEmpty(data.UnderlyingState))
            {
                model.UnderlyingState = data.UnderlyingState;
            }

            if (!string.IsNullOrEmpty(data.Desc))
            {
                model.UnderlyingDesc = data.Desc;
            }

            if (data.OptId != null)
            {
                model.OptId = data.OptId.Value;
            }

            if (!string.IsNullOrEmpty(data.OptName))
            {
                model.OptName = data.OptName;
            }

            if (data.OptDate != null && data.OptDate != DateTime.MinValue)
            {
                model.OptDate = data.OptDate.Value;
            }

            return model;
        }

        /// <summary>
        /// 查询underlying_manager
        /// </summary>
        public SearchListResult<underlying_manager> SearchList(UnderlyingManagerReq req, IEnumerable<int> vars = null)
        {
            var predicate = BuildPredicate(req, vars);
            var predicate2 = PredicateBuilder.True<Variety>();
            if (req.VarietyCodeList != null)
            {
                predicate2 = predicate2.And(d => req.VarietyCodeList.Contains(d.VarietyCode));
            }

            var query = from source in db.underlying_manager.AsNoTracking().Where(predicate)
                        join vari in db.variety.Where(predicate2) on source.UnderlyingTypeId equals vari.id into varies
                        from vari in varies.DefaultIfEmpty()
                        select source;

            //只正对资产码排序
            //if (req.sidx == "UnderlyingCode")
            //{
            //    query = req.sord == "desc"
            //        ? query.OrderByDescending(n => n.UnderlyingCode)
            //        : query.OrderBy(n => n.UnderlyingCode);
            //}
            //else
            //{
            //    query = query.OrderByDescending(n => n.id);
            //}
            var result = query.ToSearchList(req, true);
            foreach (var um in result.rows)
            {
                new DicForTranslationService(OptUserInfo.SystemUser).GetTransWord(um);
                if (um.CommodityCode == "篮子标的")
                {
                    double price = 0;
                    DataCacheProvider.GetUnderlyingDataSource().TryGetPrice(um.UnderlyingCode, out price);
                    um.Price = (double?)Convert.ToDecimal(price.ToString("0.000"));
                }
                um.Price = um.CommodityCode == "组合标的" ? new SyntheticUnderlyingPriceService(OptUserInfo.SystemUser).GetPrice(um.UnderlyingCode) : (um.Price ?? 0);
            }
            return result;
        }

        private static Expression<Func<underlying_manager, bool>> BuildPredicate(UnderlyingManagerReq req, IEnumerable<int> vars)
        {
            var predicate = PredicateBuilder.True<underlying_manager>();

            if (vars != null)
            {
                predicate = predicate.And(d => vars.Contains(d.UnderlyingTypeId));
            }

            if (!string.IsNullOrEmpty(req.UnderlyingTypeId))
            {
                var typeids = req.UnderlyingTypeId.Split(',').Select(s => Convert.ToInt32(s)).ToList();
                predicate = predicate.And(d => typeids.Contains(d.UnderlyingTypeId)); ;
            }

            if (!string.IsNullOrEmpty(req.MarketCode))
            {
                predicate = predicate.And(d => d.MarketCode == req.MarketCode);
            }

            if (!string.IsNullOrEmpty(req.MarketName))
            {
                predicate = predicate.And(d => d.MarketName.Contains(req.MarketName));
            }

            if (!string.IsNullOrEmpty(req.UnderlyingName))
            {
                predicate = predicate.And(d => d.UnderlyingName.Contains(req.UnderlyingName));
            }

            if (!string.IsNullOrEmpty(req.UnderlyingCode))
            {
                predicate = predicate.And(d => d.UnderlyingCode.Contains(req.UnderlyingCode));
            }

            if (!string.IsNullOrEmpty(req.UnderlyingType))
            {
                var underlyingTypes = req.UnderlyingType.Split(',');
                predicate = predicate.And(d => underlyingTypes.Contains(d.UnderlyingType));
            }
            if (req.MaturityDateStart != DateTime.MinValue)
            {
                predicate = predicate.And(d => d.MaturityDate >= req.MaturityDateStart);
            }

            if (req.MaturityDateEnd != DateTime.MinValue)
            {
                var MaturityDateTemp = req.MaturityDateEnd.AddDays(1);
                predicate = predicate.And(d => d.MaturityDate < MaturityDateTemp);
            }
            if (!string.IsNullOrEmpty(req.UnderlyingState))
            {
                predicate = predicate.And(d => d.UnderlyingState.Contains(req.UnderlyingState));
            }

            if (!string.IsNullOrEmpty(req.UnderlyingStatus))
            {
                predicate = predicate.And(d => req.UnderlyingStatus == d.UnderlyingStatus);
            }

            if (!string.IsNullOrEmpty(req.Desc))
            {
                predicate = predicate.And(d => d.UnderlyingDesc.Contains(req.Desc));
            }

            if (req.OptId != null)
            {
                predicate = predicate.And(d => d.OptId == req.OptId);
            }

            if (!string.IsNullOrEmpty(req.OptName))
            {
                predicate = predicate.And(d => d.OptName.Contains(req.OptName));
            }

            if (req.OptDateStart != DateTime.MinValue)
            {
                predicate = predicate.And(d => d.OptDate >= req.OptDateStart);
            }

            if (req.OptDateEnd != DateTime.MinValue)
            {
                var OptDateTemp = req.OptDateEnd.AddDays(1);
                predicate = predicate.And(d => d.OptDate < OptDateTemp);
            }

            if (!string.IsNullOrEmpty(req.LaunchState))
            {
                //0未启用，不是1
                if (req.LaunchState == "0")
                {
                    predicate = predicate.And(d => d.LaunchState != "1");
                }
                else
                {
                    predicate = predicate.And(d => d.LaunchState == req.LaunchState);
                }
            }
            if (req.MarketNameList != null)
            {
                predicate = predicate.And(d => req.MarketNameList.Contains(d.MarketName));
            }
            if (req.MarketCodeList != null)
            {
                predicate = predicate.And(d => req.MarketCodeList.Contains(d.MarketCode));
            }
            if (req.UnderlyingCodeList != null)
            {
                predicate = predicate.And(d => req.UnderlyingCodeList.Contains(d.UnderlyingCode));
            }
            if (req.UnderlyingTypeList != null)
            {
                predicate = predicate.And(d => req.UnderlyingTypeList.Contains(d.UnderlyingType));
            }
            if (req.UnderlyingStateList != null)
            {
                predicate = predicate.And(d => req.UnderlyingStateList.Contains(d.UnderlyingState));
            }

            return predicate;
        }
    }
}