using BaseOUDAL;
using Qdp.Foundation.Implementations;
using Qdp.Pricing.Base.Implementations;
using System.Data;
using System.Data.SqlTypes;
using YLErp.BLL;
using YLErp.BLL.EodSettlement;
using YLErp.DBModels.Helpers;
using YLErp.Model;
using YLErp.Models;
using YLErp.Modules.TradeDalModule;
using YLErp.Modules.TradeModule;
using YLErp.Modules.TradeModule.QueryModule;
using YLErp.QdpModule;

namespace YLErp.Modules.ClientModule
{
    /// <summary>
    /// 客户资产数据服务
    /// </summary>
    public class ClientAssetDataService
    {
        /// <summary>
        /// 结算报告：获取客户财务状况
        /// </summary>
        public static ClientSettleBalance GetClientLatestBalance(DateTime? ValueDateFrom, DateTime? ValueDateTo, int clientId, bool IsClientBalanceGap = false, bool IsGetOuterMarginGap = false, bool ParentFlag = false)
        {
            ValueDateFrom = ValueDateFrom ?? DateTime.MinValue;
            ValueDateTo = ValueDateTo ?? valuedateBLL.ValueDate;
            var cb = ClientBalanceUtility.GetClientBanlances(new List<int> { clientId }, ValueDateFrom.Value, ValueDateTo.Value, IsClientBalanceGap, IsGetOuterMarginGap, ParentFlag).FirstOrDefault();
            if (PS.Config.Company == Configuration.CompanyEnum.润和)
            {
                cb.SettlementBalance += cb.SwapBalance;
            }
            return cb ?? new ClientSettleBalance();
        }

        /// <summary>
        /// 结算报告：获取客户历史交易
        /// </summary>
        public static SearchListResult<trade_contract_group_simple> GetClientTradeHistory(DateTime? valueDateFrom, DateTime? valueDateTo, int? clientId, int page, int pageRowCount)
        {
            return tradeHistoryQueryV2(new TradeReq()
            {
                ValueDateStart = valueDateFrom ?? DateTime.MinValue,
                ValueDateEnd = valueDateTo ?? DateTime.MaxValue,
                ClientId = clientId.Value,
                page = page,
                rows = pageRowCount
            });
        }

        /// <summary>
        /// 历史交易查询
        /// </summary>
        public static SearchListResult<trade_contract_group_simple> tradeHistoryQuery(TradeReq req)
        {
            var sList = new TradeHistoryQueryService(OptUserInfo.SystemUser).SearchHistoryList(req, out var gsum);
            var rowList = sList.rows;
            new TradeDalService(OptUserInfo.SystemUser).SetStructureInfo(rowList.Select(r => r.trade));
            if (rowList != null && rowList.Any())
            {
                foreach (var group in rowList)
                {
                    if (group.trade.TradeType == "合成价差期权")
                    {
                        group.trade.SyntheticUnderlyingTipsInfo =
                            synthetic_underlyingBLL.GetUnderlyingTipsInfo(group.trade.UnderlyingCode);
                    }
                    group.trade.TradeSinglePrice = group.trade.TradeSinglePrice.IsNormalize() ? (double?)Math.Abs(group.trade.TradeSinglePrice.Value) : group.trade.TradeSinglePrice;
                }
            }
            return sList;
        }

        public static SearchListResult<trade_contract_group_simple> tradeHistoryQueryV2(TradeReq req)
        {
            var sList = new TradeHistoryQueryService(OptUserInfo.SystemUser).SearchHistoryList(req, out var gsum);
            var rowList = sList.rows;

            new TradeDalService(OptUserInfo.SystemUser).SetStructureInfo(rowList.Select(r => r.trade));
            if (rowList != null && rowList.Any())
            {
                foreach (var group in rowList)
                {
                    if (group.trade.TradeType == "合成价差期权")
                    {
                        group.trade.SyntheticUnderlyingTipsInfo =
                            synthetic_underlyingBLL.GetUnderlyingTipsInfo(group.trade.UnderlyingCode);
                    }
                }
            }
            var underlyingCodes = sList.rows.Select(x => x.trade.UnderlyingCode).ToList();
            var underlyings = synthetic_underlyingBLL.GetQuery().Where(s => underlyingCodes.Contains(s.Name));

            foreach (var r in sList.rows)
            {
                ProcessTradeContractGroupForTradeHistory(r, underlyings);
            }

            return sList;
        }

        /// <summary>
        /// 查询所有历史交易数据
        /// </summary>
        public static List<trade_contract_group_simple> SearchHistoryListOnly(TradeReq req, bool isFromTradeMarketReport = false)
        {
            var sList = new TradeHistoryQueryService(OptUserInfo.SystemUser)
                .SearchHistoryListOnly(req, isFromTradeMarketReport);

            var underlyingCodes = sList.Select(x => x.trade.UnderlyingCode).ToList();
            var underlyings = synthetic_underlyingBLL.GetQuery().Where(s => underlyingCodes.Contains(s.Name));

            var otcTrades = sList.Select(x => new OtcTradeBase
            {
                id = x.trade.id,
                IsMoneynessOption = x.trade.IsMoneynessOption,
                IsUsePremiumRate = x.trade.IsUsePremiumRate,
                ParticipationRate = x.trade.ParticipationRate,
                PrincipalRate = x.trade.PrincipalRate,
                TradeType = x.trade.StructureType ?? x.trade.TradeType,
                TradePrice = x.trade.TradePrice,
                TradeSinglePrice = x.trade.TradeSinglePrice,
                PremiumRate = x.trade.PremiumRate,
                UnderlyingCode = x.trade.UnderlyingCode,
                UnderlyingId = x.trade.UnderlyingId,
            }).ToList();

            new TradeExtendService(OptUserInfo.SystemUser).SetTradeExtendWithCnKey(otcTrades, true);

            using (var db = new YLContext())
            {
                var tradecashids = sList.Select(x => x.trade_cash.id).ToHashSet();
                var trade_cash_swaps = db.trade_cash_swap.Where(y => tradecashids.Contains(y.TradeCashId)).Select(n => new { n.TradeCashId, n.GetFinalPrice, n.PayFinalPrice }).ToList();

                sList.ForEach(x =>
                {
                    ProcessTradeContractGroupForTradeHistory(x, underlyings);

                    x.dic = otcTrades.FirstOrDefault(y => y.id == x.trade.id)?.MetaDic;
                    if (x.TradeType == "收益互换")
                    {
                        var trade_cash_swap = trade_cash_swaps.FirstOrDefault(n => n.TradeCashId == x.trade_cash.id);
                        if (trade_cash_swap != null)
                        {
                            x.dic["互换_支付方到期标的价格"] = trade_cash_swap.PayFinalPrice.OtcFormatUmPrice();
                            x.dic["互换_收取方到期标的价格"] = trade_cash_swap.GetFinalPrice.OtcFormatUmPrice();
                        }
                    }
                    x.trade.TradeType = x.trade.IsGroup == 1 ? x.trade.StructureType : x.trade.TradeType;
                });
            }
            return sList;
        }

        private static void ProcessTradeContractGroupForTradeHistory(trade_contract_group_simple tr, IQueryable<SyntheticUnderlying> syntheticUnderlyings)
        {
            var underlying = DataCacheProvider.GetUnderlyingDataSource().GetData(tr.trade.UnderlyingCode);

            tr.trade_cash.WinLoss = tr.WinLoss.ToString("F3");
            tr.trade_cash.SingleWinPrice = Math.Abs(tr.trade_cash.Action == "系统操作-平仓费" && tr.trade.IsUsePremiumRate == true ? TradeHelper.GetTradeSinglePriceByPremiumRate(tr.trade_cash.UnwindPricePercentRate, tr.trade.SpotPrice) : (tr.trade_cash.UnwindPrice ?? 0));
            tr.trade_cash.SingleWinPriceString = tr.trade.IsUsePremiumRate == true && tr.trade_cash.Action == "系统操作-平仓费" ? (tr.trade_cash.UnwindPricePercentRate ?? 0).OtcFormat(OtcFormatFlag.premiumRateP) : tr.trade_cash.SingleWinPrice.OtcFormat(OtcFormatFlag.tradeSinglePrice);
            tr.trade_cash.ActionNotional = (tr.trade_cash.Action == "系统操作-行权费" ? tr.trade_cash.Notional : (tr.trade_cash.UnwindNotional == null ? 0 : tr.trade_cash.UnwindNotional)).Value.ToString("0.00");
            tr.trade_cash.ActionTradeAmount = (tr.trade_cash.Action == "系统操作-行权费" || tr.trade_cash.Action == "系统操作-期权费" ? (tr.trade_cash.TradeAmount == null ? 0 : tr.trade_cash.TradeAmount) : (tr.trade_cash.UnwindTradeAmount == null ? 0 : tr.trade_cash.UnwindTradeAmount)).Value;
            tr.trade_cash.ActionTradeAmountV = tr.TradeType == "累计期权" ? tr.trade_cash.ActionTradeAmount : tr.trade_cash.ActionTradeAmount / ((tr.trade.ParticipationRate * tr.trade.AnnualizeFactor) ?? 1);
            if (PS.Config.IsUseDisplayNotional)
            {
                tr.trade_cash.ActionTradeAmount = tr.trade_cash.ActionTradeAmount * underlying.CountRatio;
                tr.trade_cash.ActionTradeAmountV = tr.trade_cash.ActionTradeAmountV * underlying.CountRatio;
            }
            if (PS.Config.ErpElement.IsSettlementReportAccOptionContainMultiplier && tr.TradeType == "累计期权" && tr.trade.trade_accumulator_option != null)
            {
                // 累计了结时相应的乘数(标准累计：看涨乘数，看跌乘数；三段式：乘数1，乘数2，乘数3)  当乘数为0不处理
                tr.trade.trade_accumulator_option = new YLContext().trade_accumulator_option.Where(l => l.TradeId == tr.trade.id).FirstOrDefault();
                var multiplier = GetTradeAccumulatorOptionMultiplier(tr.trade, tr.trade_cash.FinalPrice.Value, tr.trade_cash.ValueDate);
                if (multiplier != 0)
                {
                    tr.trade_cash.ActionTradeAmount = tr.trade_cash.ActionTradeAmount * multiplier;
                    tr.trade_cash.ActionTradeAmountV = tr.trade_cash.ActionTradeAmountV * multiplier;
                    tr.trade_cash.SingleWinPriceString = tr.trade.IsUsePremiumRate == true && tr.trade_cash.Action == "系统操作-平仓费" ? Math.Abs(tr.trade_cash.MinusAmount / tr.trade_cash.ActionTradeAmountV).OtcFormat(OtcFormatFlag.premiumRateP) : Math.Abs(tr.trade_cash.MinusAmount / tr.trade_cash.ActionTradeAmountV).OtcFormat(OtcFormatFlag.tradeSinglePrice);
                }
            }
            tr.TradeStatusShow = TradeHelper.GetTradeStatus(tr.trade, tr.trade_cash);

            if (!ConsTrade.TradeTypesForHedge.Contains(tr.trade.TradeType))
            {

                if (underlying != null && underlying.UnderlyingInstrumentType != "Stock")
                {
                    tr.trade.TradeOriginalAmount = tr.trade.OriginalNotional / underlying.CountRatio;
                }
                else
                {
                    tr.trade.TradeOriginalAmount = tr.trade.OriginalNotional;
                }
            }

            tr.trade.TradeSinglePrice = tr.trade.TradeSinglePrice.IsNormalize() ? (double?)Math.Abs(tr.trade.TradeSinglePrice.Value) : tr.trade.TradeSinglePrice;
            tr.trade.UnderlyingCode = tr.trade.TradeType == "合成价差期权" ? (syntheticUnderlyings.FirstOrDefault(y => y.Name == tr.trade.UnderlyingCode) == null ? tr.trade.UnderlyingCode : syntheticUnderlyings.FirstOrDefault(y => y.Name == tr.trade.UnderlyingCode).UnderlyingTipsInfo) : tr.trade.UnderlyingCode;
        }

        /// <summary>
        /// 根据结算报告历史数据 获取每条历史累计期权乘数
        /// </summary>
        /// <param name="t">trade</param>
        /// <param name="_closePrice">终止/到期标的价格</param>
        /// <param name="_valueDate">了结日期</param>
        /// <returns>相对应的乘数</returns>
        public static double GetTradeAccumulatorOptionMultiplier(trade t, double _closePrice, DateTime _valueDate)
        {
            bool _updownPriceMode = GlobalConfig.AccumulatorCriticalMode == "updown";
            var _td = t;
            var _tdAcc = _td.trade_accumulator_option;
            var customObservDates = QdpHelper.ParseAutocallCustomizedInfo(_tdAcc.KOObservationDates);
            var koObservationDates = customObservDates.Item1;
            var customKOBarriers = customObservDates.Item2;
            if (koObservationDates == null)
            {
                koObservationDates = CalendarImpl.Get("chn").BizDaysBetweenDatesExcluStartDay(_td.TradeDate.Value, _td.ExerciseDate.Value).ToArray();
            }
            var valueDateIndex = Array.IndexOf(koObservationDates, new Date(_valueDate));
            if (valueDateIndex < 0)
            {
                //从业务角度来说 没有这种可能性的数据会进入这个判断，后续有问题再处理
                return 0;
            }
            var strike = _td.Strike ?? 0;
            double? barrier = _tdAcc.KOBarrier;
            if (customKOBarriers != null && customKOBarriers.Length > valueDateIndex)
            {
                barrier = customKOBarriers[valueDateIndex];
            }
            if (_td.IsMoneynessOptionData)
            {
                strike *= _td.SpotPrice.Value;
                barrier *= _td.SpotPrice.Value;
            }
            if (!barrier.HasValue)
            {
                barrier = ConsGlobal.CallPut.IsCall(_td.OptionType) ? 1e10 : -1e10;
            }
            double multiplier = 1;
            if (_tdAcc.AccumulatorStructureType == AccumulatorStructureTypeEnum.Segmented)
            {
                var strike2 = _tdAcc.Strike2 ?? 0;
                var strike3 = _tdAcc.Strike3 ?? 0;
                if (_td.OptionType == "看涨")
                {
                    //腿一
                    if (_closePrice < strike)
                    {
                        multiplier = (_tdAcc.Multiplier ?? 0);
                    }
                    else if ((Math.Abs(_closePrice - strike) < 1e-6) || _closePrice < strike2 || (Math.Abs(_closePrice - strike2) < 1e-6 && _tdAcc.PayoffType == "浮动"))//K1<=S<=K2 || UpdownPriceMode && K1<=S<K2   payoff 0
                    {
                        multiplier = 0;
                    }
                    //腿二
                    else if (_closePrice < barrier || Math.Abs(_closePrice - barrier.Value) < 1e-6 || (Math.Abs(_closePrice - strike2) < 1e-6 && _tdAcc.PayoffType == "固定"))//K2<S<B || UpdownPriceMode && K2<S<=B   payoff Acall1*(S-K2) or c1
                    {
                        multiplier = (_tdAcc.Multiplier2 ?? 0);
                    }
                    else if (_closePrice > strike3 || (Math.Abs(_closePrice - strike3) < 1e-6 && _tdAcc.PayoffType == "固定"))
                    {
                        multiplier = (_tdAcc.Multiplier3 ?? 0);
                    }
                    else
                    {
                        multiplier = 0;
                    }
                }
                else
                {
                    if (_closePrice < strike || (Math.Abs(_closePrice - strike) < 1e-6 && _tdAcc.PayoffType == "固定"))
                    {
                        multiplier = (_tdAcc.Multiplier ?? 0);
                    }
                    else if (_closePrice < barrier || (Math.Abs(_closePrice - strike) < 1e-6 && _tdAcc.PayoffType == "浮动"))
                    {
                        multiplier = 0;
                    }
                    else if (Math.Abs(barrier.Value - strike2) < 1e-6 || _closePrice < strike2 || (Math.Abs(_closePrice - strike2) < 1e-6 && _tdAcc.PayoffType == "固定"))
                    {
                        multiplier = (_tdAcc.Multiplier2 ?? 0);
                    }
                    else if (_closePrice > strike3)
                    {
                        multiplier = (_tdAcc.Multiplier3 ?? 0);
                    }
                    else
                    {
                        multiplier = 0;
                    }
                }
            }
            else
            {
                if (_td.OptionType == "看涨")
                {
                    //超出上限则敲出
                    if (_closePrice > barrier || _updownPriceMode && Math.Abs(_closePrice - barrier.Value) < 1e-6)
                    {
                        multiplier = 0;
                    }
                    //低于下限(执行价格)则买方赔付(使用看跌乘数)
                    else if (_closePrice < strike || _updownPriceMode && Math.Abs(_closePrice - strike) < 1e-6)
                    {
                        multiplier = _tdAcc.PutMultiplier;
                    }
                    //在上下限之间则买方获得收益(使用看涨乘数)
                    else
                    {
                        multiplier = _tdAcc.CallMultiplier;
                    }
                }
                else
                {
                    //低于下限则敲出
                    if (_closePrice < barrier || _updownPriceMode && Math.Abs(_closePrice - barrier.Value) < 1e-6)
                    {
                        multiplier = 0;
                    }
                    //超过上限(执行价)则买方赔付(使用看涨乘数)
                    else if (_closePrice > strike || _updownPriceMode && Math.Abs(_closePrice - strike) < 1e-6)
                    {
                        multiplier = _tdAcc.CallMultiplier;
                    }
                    //在上下限之间则买方获得收益(使用看跌乘数)
                    else
                    {
                        multiplier = _tdAcc.PutMultiplier;
                    }
                }
            }
            return multiplier;
        }

        /// <summary>
        /// 结算报告：客户资金记录
        /// </summary>
        public static SearchListResult<ClientCashInCashOutExtend> GetClientCashRecords(DateTime? valueDateFrom, DateTime? valueDateTo, int? clientId, int page, int pageRowCount)
        {
            return ExecutedCashList(new EntryExitReq()
            {
                HappenDateStart = valueDateFrom ?? DateTime.MinValue,
                HappenDateEnd = valueDateTo ?? DateTime.MaxValue,
                ClientId = clientId.Value,
                page = page,
                rows = pageRowCount
            });
        }

        /// <summary>
        /// 
        /// </summary>
        public static SearchListResult<ClientCashInCashOutExtend> ExecutedCashList(EntryExitReq req)
        {
            var bll = new EntryExitBLL();
            req.State = "已确认,已结算";
            req.Direction = $"入金,出金,其他收入,其他支出,应收";
            req.TradeAction =
                $"{ClientCashInCashOut.系统操作_行权费},{ClientCashInCashOut.系统操作_平仓费},{ClientCashInCashOut.系统操作_期权费},{ClientCashInCashOut.系统操作_票息},{ClientCashInCashOut.系统操作_互换},{ClientCashInCashOut.系统操作_应付预付金},{ClientCashInCashOut.系统操作_预付金返息}";
            req.IsMoneyNotEqualsZero = true;
            var sList = bll.SearchListExtendWithGroup(req, out _, includeHoliday: true);

            foreach (var item in sList.rows)
            {
                if (item.ClientId > 0)
                {
                    item.ClientName = DataCacheProvider.GetClientDataSource().GetData(item.ClientId.Value)?.Name;
                }
            }

            return sList;
        }

        /// <summary>
        /// 查询clientbalance
        /// </summary>
        /// <param name="req"></param>
        /// <returns></returns>
        public static List<ClientBalanceDaily> SearchList(ClientBalanceRequest req)
        {
            var result = new List<ClientBalanceDaily>();

            using (var db = new YLContext())
            {
                if (req.BalanceDate == null || req.BalanceDate == DateTime.MinValue)
                {
                    req.BalanceDate = db.ClientBalanceDaily.Select(n => new { n.BalanceDate })
                        .OrderByDescending(n => n.BalanceDate).FirstOrDefault()?.BalanceDate;
                }

                var query = db.ClientBalanceDaily.Where(n => n.BalanceDate == req.BalanceDate.Value);

                if (req.ClientId != null)
                {
                    query = query.Where(d => d.ClientId == req.ClientId);
                }

                if (!string.IsNullOrEmpty(req.ClientName))
                {
                    query = query.Where(d => d.ClientName.Contains(req.ClientName));
                }

                if (!string.IsNullOrEmpty(req.ClientNumber))
                {
                    query = query.Where(d => d.ClientNumber.Contains(req.ClientNumber));
                }

                if (req.LastDayRemainFund != null)
                {
                    query = query.Where(d => d.LastDayRemainFund == req.LastDayRemainFund);
                }

                if (req.InFund != null)
                {
                    query = query.Where(d => d.InFund == req.InFund);
                }

                if (req.OutFund != null)
                {
                    query = query.Where(d => d.OutFund == req.OutFund);
                }

                if (req.DayGainLoss != null)
                {
                    query = query.Where(d => d.DayGainLoss == req.DayGainLoss);
                }

                if (!string.IsNullOrEmpty(req.State))
                {
                    query = query.Where(d => d.State.Contains(req.State));
                }

                if (req.OptId != null)
                {
                    query = query.Where(d => d.OptId == req.OptId);
                }

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

                if (req.OptDateStart != DateTime.MinValue && req.OptDateStart != SqlDateTime.MinValue.Value)
                {
                    query = query.Where(d => d.OptDate >= req.OptDateStart);
                }

                if (req.OptDateEnd != DateTime.MinValue && req.OptDateEnd != SqlDateTime.MinValue.Value)
                {
                    var OptDateTemp = req.OptDateEnd.AddDays(1);
                    query = query.Where(d => d.OptDate < OptDateTemp);
                }

                if (req.ClientNameList != null)
                { query = query.Where(d => req.ClientNameList.Contains(d.ClientName)); }

                if (req.ClientNumberList != null)
                { query = query.Where(d => req.ClientNumberList.Contains(d.ClientNumber)); }

                if (req.ToDayRemainFundStart != null)
                {
                    if (req.ToDayRemainFundStart == req.ToDayRemainFundEnd)
                    { query = query.Where(d => req.ToDayRemainFundStart == d.ToDayRemainFund); }
                    else { query = query.Where(d => req.ToDayRemainFundStart <= d.ToDayRemainFund); }
                }
                if (req.ToDayRemainFundEnd != null && req.ToDayRemainFundStart != req.ToDayRemainFundEnd)
                { query = query.Where(d => req.ToDayRemainFundEnd >= d.ToDayRemainFund); }

                if (req.LastDayRemainFundStart != null)
                {
                    if (req.LastDayRemainFundStart == req.LastDayRemainFundEnd)
                    { query = query.Where(d => req.LastDayRemainFundStart == d.LastDayRemainFund); }
                    else { query = query.Where(d => req.LastDayRemainFundStart <= d.LastDayRemainFund); }
                }
                if (req.LastDayRemainFundEnd != null && req.LastDayRemainFundStart != req.LastDayRemainFundEnd)
                { query = query.Where(d => req.LastDayRemainFundEnd >= d.LastDayRemainFund); }

                if (req.InFundStart != null)
                {
                    if (req.InFundStart == req.InFundEnd)
                    { query = query.Where(d => req.InFundStart == d.InFund); }
                    else { query = query.Where(d => req.InFundStart <= d.InFund); }
                }
                if (req.InFundEnd != null && req.InFundStart != req.InFundEnd)
                { query = query.Where(d => req.InFundEnd >= d.InFund); }

                if (req.OutFundStart != null)
                {
                    if (req.OutFundStart == req.OutFundEnd)
                    { query = query.Where(d => req.OutFundStart == d.OutFund); }
                    else { query = query.Where(d => req.OutFundStart <= d.OutFund); }
                }
                if (req.OutFundEnd != null && req.OutFundStart != req.OutFundEnd)
                { query = query.Where(d => req.OutFundEnd >= d.OutFund); }

                if (req.DayGainLossStart != null)
                {
                    if (req.DayGainLossStart == req.DayGainLossEnd)
                    { query = query.Where(d => req.DayGainLossStart == d.DayGainLoss); }
                    else { query = query.Where(d => req.DayGainLossStart <= d.DayGainLoss); }
                }
                if (req.DayGainLossEnd != null && req.DayGainLossStart != req.DayGainLossEnd)
                { query = query.Where(d => req.DayGainLossEnd >= d.DayGainLoss); }

                if (req.OptionPremiumStart != null)
                {
                    if (req.OptionPremiumStart == req.OptionPremiumEnd)
                    { query = query.Where(d => req.OptionPremiumStart == d.OptionPremium); }
                    else { query = query.Where(d => req.OptionPremiumStart <= d.OptionPremium); }
                }
                if (req.OptionPremiumEnd != null && req.OptionPremiumStart != req.OptionPremiumEnd)
                { query = query.Where(d => req.OptionPremiumEnd >= d.OptionPremium); }

                if (req.SettlementBalanceStart != null)
                {
                    if (req.SettlementBalanceStart == req.SettlementBalanceEnd)
                    { query = query.Where(d => req.SettlementBalanceStart == d.SettlementBalance); }
                    else { query = query.Where(d => req.SettlementBalanceStart <= d.SettlementBalance); }
                }
                if (req.SettlementBalanceEnd != null && req.SettlementBalanceStart != req.SettlementBalanceEnd)
                { query = query.Where(d => req.SettlementBalanceEnd >= d.SettlementBalance); }

                if (req.MarginStart != null)
                {
                    if (req.MarginStart == req.MarginEnd)
                    { query = query.Where(d => req.MarginStart == d.Margin); }
                    else { query = query.Where(d => req.MarginStart <= d.Margin); }
                }
                if (req.MarginEnd != null && req.MarginStart != req.MarginEnd)
                { query = query.Where(d => req.MarginEnd >= d.Margin); }

                if (req.NetFundStart != null)
                {
                    if (req.NetFundStart == req.NetFundEnd)
                    { query = query.Where(d => req.NetFundStart == d.NetFund); }
                    else { query = query.Where(d => req.NetFundStart <= d.NetFund); }
                }
                if (req.NetFundEnd != null && req.NetFundStart != req.NetFundEnd)
                { query = query.Where(d => req.NetFundEnd >= d.NetFund); }

                if (req.MarginBalanceStart != null)
                {
                    if (req.MarginBalanceStart == req.MarginBalanceEnd)
                    { query = query.Where(d => req.MarginBalanceStart == d.MarginBalance); }
                    else { query = query.Where(d => req.MarginBalanceStart <= d.MarginBalance); }
                }
                if (req.MarginBalanceEnd != null && req.MarginBalanceStart != req.MarginBalanceEnd)
                { query = query.Where(d => req.MarginBalanceEnd >= d.MarginBalance); }

                if (req.FrozenPremiumStart != null)
                {
                    if (req.FrozenPremiumStart == req.FrozenPremiumEnd)
                    { query = query.Where(d => req.FrozenPremiumStart == d.FrozenPremium); }
                    else { query = query.Where(d => req.FrozenPremiumStart <= d.FrozenPremium); }
                }
                if (req.FrozenPremiumEnd != null && req.FrozenPremiumStart != req.FrozenPremiumEnd)
                { query = query.Where(d => req.FrozenPremiumEnd >= d.FrozenPremium); }

                if (req.FrozenBalanceStart != null)
                {
                    if (req.FrozenBalanceStart == req.FrozenBalanceEnd)
                    { query = query.Where(d => req.FrozenBalanceStart == d.FrozenBalance); }
                    else { query = query.Where(d => req.FrozenBalanceStart <= d.FrozenBalance); }
                }
                if (req.FrozenBalanceEnd != null && req.FrozenBalanceStart != req.FrozenBalanceEnd)
                { query = query.Where(d => req.FrozenBalanceEnd >= d.FrozenBalance); }

                if (req.CopeWithExpirePremiumStart != null)
                {
                    if (req.CopeWithExpirePremiumStart == req.CopeWithExpirePremiumEnd)
                    { query = query.Where(d => req.CopeWithExpirePremiumStart == d.CopeWithExpirePremium); }
                    else { query = query.Where(d => req.CopeWithExpirePremiumStart <= d.CopeWithExpirePremium); }
                }
                if (req.CopeWithExpirePremiumEnd != null && req.CopeWithExpirePremiumStart != req.CopeWithExpirePremiumEnd)
                { query = query.Where(d => req.CopeWithExpirePremiumEnd >= d.CopeWithExpirePremium); }

                if (req.CopeWithLastPremiumStart != null)
                {
                    if (req.CopeWithLastPremiumStart == req.CopeWithLastPremiumEnd)
                    { query = query.Where(d => req.CopeWithLastPremiumStart == d.CopeWithLastPremium); }
                    else { query = query.Where(d => req.CopeWithLastPremiumStart <= d.CopeWithLastPremium); }
                }
                if (req.CopeWithLastPremiumEnd != null && req.CopeWithLastPremiumStart != req.CopeWithLastPremiumEnd)
                { query = query.Where(d => req.CopeWithLastPremiumEnd >= d.CopeWithLastPremium); }

                if (req.PvStart != null)
                {
                    if (req.PvStart == req.PvEnd)
                    { query = query.Where(d => req.PvStart == d.Pv); }
                    else { query = query.Where(d => req.PvStart <= d.Pv); }
                }
                if (req.PvEnd != null && req.PvStart != req.PvEnd)
                { query = query.Where(d => req.PvEnd >= d.Pv); }

                if (req.TotalNominalStart != null)
                {
                    if (req.TotalNominalStart == req.TotalNominalEnd)
                    { query = query.Where(d => req.TotalNominalStart == d.TotalNominal); }
                    else { query = query.Where(d => req.TotalNominalStart <= d.TotalNominal); }
                }
                if (req.TotalNominalEnd != null && req.TotalNominalStart != req.TotalNominalEnd)
                { query = query.Where(d => req.TotalNominalEnd >= d.TotalNominal); }

                if (req.PayableMarginStart != null)
                {
                    if (req.PayableMarginStart == req.PayableMarginEnd)
                    { query = query.Where(d => req.PayableMarginStart == d.PayableMargin); }
                    else { query = query.Where(d => req.PayableMarginStart <= d.PayableMargin); }
                }
                if (req.PayableMarginEnd != null && req.PayableMarginStart != req.PayableMarginEnd)
                { query = query.Where(d => req.PayableMarginEnd >= d.PayableMargin); }

                if (req.AdvisableMarginStart != null)
                {
                    if (req.AdvisableMarginStart == req.AdvisableMarginEnd)
                    { query = query.Where(d => req.AdvisableMarginStart == d.AdvisableMargin); }
                    else { query = query.Where(d => req.AdvisableMarginStart <= d.AdvisableMargin); }
                }
                if (req.AdvisableMarginEnd != null && req.AdvisableMarginStart != req.AdvisableMarginEnd)
                { query = query.Where(d => req.AdvisableMarginEnd >= d.AdvisableMargin); }

                if (req.CreditStart != null)
                {
                    if (req.CreditStart == req.CreditEnd)
                    { query = query.Where(d => req.CreditStart == d.Credit); }
                    else { query = query.Where(d => req.CreditStart <= d.Credit); }
                }
                if (req.CreditEnd != null && req.CreditStart != req.CreditEnd)
                { query = query.Where(d => req.CreditEnd >= d.Credit); }

                if (req.TodayRemianFundProductStart != null)
                {
                    if (req.TodayRemianFundProductStart == req.TodayRemianFundProductEnd)
                    { query = query.Where(d => req.TodayRemianFundProductStart == d.TodayRemianFundProduct); }
                    else { query = query.Where(d => req.TodayRemianFundProductStart <= d.TodayRemianFundProduct); }
                }
                if (req.TodayRemianFundProductEnd != null && req.TodayRemianFundProductStart != req.TodayRemianFundProductEnd)
                { query = query.Where(d => req.TodayRemianFundProductEnd >= d.TodayRemianFundProduct); }

                if (req.CashInCashOutProductChangeStart != null)
                {
                    if (req.CashInCashOutProductChangeStart == req.CashInCashOutProductChangeEnd)
                    { query = query.Where(d => req.CashInCashOutProductChangeStart == d.CashInCashOutProductChange); }
                    else { query = query.Where(d => req.CashInCashOutProductChangeStart <= d.CashInCashOutProductChange); }
                }
                if (req.CashInCashOutProductChangeEnd != null && req.CashInCashOutProductChangeStart != req.CashInCashOutProductChangeEnd)
                { query = query.Where(d => req.CashInCashOutProductChangeEnd >= d.CashInCashOutProductChange); }

                if (string.IsNullOrEmpty(req.sidx))
                {
                    req.sidx = "id";
                    req.sord = "desc";
                }
                result = query.ToList();
            }

            return result;
        }
    }
}