using CxxCalcLib;
using Qdp.ComputeService.Data.CommonModels.ValuationParams.Equity;
using Qdp.ComputeService.Data.CommonModels.ValuationParams.FixedIncome;
using Qdp.ComputeServiceV2.Data.CommonModels.TradeInfos;
using Qdp.ComputeServiceV2.Data.CommonModels.TradeInfos.Options;
using Qdp.Foundation.Implementations;
using Qdp.Pricing.Base.Enums;
using Qdp.Pricing.Base.Implementations;
using Qdp.Pricing.Base.Interfaces;
using Qdp.Pricing.Base.Utilities;
using Qdp.Pricing.Ecosystem.Market;
using Qdp.Pricing.Library.Common.Base;
using Qdp.Pricing.Library.Common.Interfaces;
using Qdp.Pricing.Library.Common.Products.Rates.Engines;
using Qdp.Pricing.Library.Options.Products.Accumulator.Engines.Analytical;
using Qdp.Pricing.Library.Options.Products.Accumulator.Engines.Numerical;
using Qdp.Pricing.Library.Options.Products.Airbag;
using Qdp.Pricing.Library.Options.Products.Airbag.Engines.Analytical;
using Qdp.Pricing.Library.Options.Products.Asian;
using Qdp.Pricing.Library.Options.Products.AsianSyntheticSpread.Engines.Analytical;
using Qdp.Pricing.Library.Options.Products.Autocall.Phoenix;
using Qdp.Pricing.Library.Options.Products.Autocall.Phoenix.Numerical;
using Qdp.Pricing.Library.Options.Products.Autocall.Snowball;
using Qdp.Pricing.Library.Options.Products.Barrier;
using Qdp.Pricing.Library.Options.Products.Binary;
using Qdp.Pricing.Library.Options.Products.DoubleSharkFin;
using Qdp.Pricing.Library.Options.Products.PayoffEnhance;
using Qdp.Pricing.Library.Options.Products.PayoffEnhance.Engines.Analytical;
using Qdp.Pricing.Library.Options.Products.RangeAccrual;
using Qdp.Pricing.Library.Options.Products.Vanilla;
using YLErp.BLL.Calculation;
using YLErp.BLL.Calculation.Engine;
using YLErp.BLL.Calculation.V2;
using YLErp.Commons;
using YLErp.Enums;
using YLErp.Modules.ApiModule;
using YLErp.Modules.CalculationLogModule;
using YLErp.Modules.CalculationModule.Abstract;
using YLErp.QdpModule;

namespace YLErp.Modules.CalculationModule
{
    /// <summary>
    /// 交易风险计算(这个类中的MarketProxy应该是已经准备好波动率和价格的对象)
    /// </summary>
    public static class TradeRiskCalcUtil
    {
        /// <summary>
        /// 获取Qdp数据
        /// </summary>
        public static TradeValueResult CalcTradeRisk(OtcTradeBase tradeObj, IOtcTradeValueCalcContext context,
            out underlying_manager[] underlyings)
        {
            if (tradeObj == null)
            {
                throw new ArgumentNullException(nameof(tradeObj));
            }

            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            if (string.IsNullOrWhiteSpace(tradeObj.UnderlyingCode) && tradeObj.TradeType != "现金流交易")
            {
                throw new TradeCalcExpception(tradeObj.id, "UnderlyingCode为空");
            }

            if (context.MarketProxy == null)
            {
                throw new ArgumentNullException("context.Market");
            }

            return new TradeRiskValueCalc(context, tradeObj).GetTradeValue(out underlyings);
        }

        #region----CalcHelper----

        class InnerCalcHelper : IDisposable
        {
            protected readonly MarketProxy _marketProxy;

            protected string _dividendCurveName;

            public InnerCalcHelper(MarketProxy marketProxy)
            {
                _marketProxy = marketProxy;
            }

            public virtual void Dispose()
            {
                if (!string.IsNullOrEmpty(_dividendCurveName))
                {
                    _marketProxy.RemoveYieldCurve(_dividendCurveName);
                    _dividendCurveName = null;
                }
            }

            protected void PrepareBase<T>(OptionCalcParam<T> calcParam) where T : OptionTradeParamBase
            {
                _dividendCurveName = null;

                //分红率曲线
                if (!calcParam.TradeParam.isForwardTrade)
                {
                    var dividendRate = calcParam.TradeParam.dividendRate;
                    if (dividendRate > 0)
                    {
                        _dividendCurveName = Guid.NewGuid().ToString();
                        var dividendCurve = CalculatorHelper.CreateConstantRiskFreeCurve(_dividendCurveName, dividendRate);
                        _marketProxy.SetYieldCurve(_dividendCurveName, dividendCurve);
                    }
                }
            }
        }

        class SingleUnderlyingCalcHelper : InnerCalcHelper
        {
            string volSurfaceName;

            double spotPrice;

            public string underlyingTicker { get; private set; }

            public SingleUnderlyingCalcHelper(MarketProxy marketProxy) : base(marketProxy)
            {

            }

            public SingleUnderlyingCalcHelper Prepare<T>(OptionCalcParam<T> calcParam, bool noUnderlying = false) where T : OptionTradeParamBase
            {
                if (calcParam is null)
                {
                    throw new ArgumentNullException(nameof(calcParam));
                }

                if (!noUnderlying)
                {
                    if (calcParam.spotPrices == null || !calcParam.spotPrices.Any())
                    {
                        throw new Exception("期权计算缺少标的现价");
                    }

                    if (calcParam.underlyingTickers == null || !calcParam.underlyingTickers.Any())
                    {
                        throw new Exception("期权计算缺少标的");
                    }

                    spotPrice = calcParam.spotPrices[0];
                    underlyingTicker = calcParam.underlyingTickers[0];

                    OptimizeSpotPrice(ref spotPrice, calcParam.TradeParam.GetAbsStrike());

                    //设置标的价格
                    _marketProxy.SetStockPrice(underlyingTicker, spotPrice);
                }

                if (calcParam.volSurfaceNames == null || !calcParam.volSurfaceNames.Any())
                {
                    throw new Exception("期权计算缺少波动率");
                }

                volSurfaceName = calcParam.volSurfaceNames[0];

                PrepareBase(calcParam);

                return this;
            }

            public OptionValuationParameters GetValuationParameters()
            {
                return new OptionValuationParameters(_marketProxy.DiscountCurveName ?? MarketProxy.ConstantZeroCurve,
                    _dividendCurveName ?? MarketProxy.ConstantZeroCurve, volSurfaceName, underlyingTicker);
            }
        }

        /// <summary>
        /// 计算T+1日Delta
        /// </summary>
        static double? CalcDeltaT1(TradeBase optionTrade, PrebuiltQdpMarket baseMarket, IEngine engine, OptionValuationParameters parameters)
        {
            var variety = DataCacheProvider.GetVariety(parameters.UnderlyingId);
            var referenceDateAddOne = baseMarket.ReferenceDate.AddDays(1);
            var nextDay = QdpCalendarHelper.GetNonHoliday(referenceDateAddOne);

            if (nextDay > optionTrade.MaturityDate.DateTime)
            {
                return null;
            }

            var market = new PrebuiltQdpMarket(nextDay.ToString("yyyy-MM-dd"), nextDay)
            {
                YieldCurves = baseMarket.YieldCurves,
                StockPrices = baseMarket.StockPrices,
                VolSurfaces = baseMarket.VolSurfaces,
                CorrSurfaces = baseMarket.CorrSurfaces
            };

            var isAsianOption = false;
            if (optionTrade.Instrument is AsianOption asianOption && asianOption.Fixings != null)
            {
                isAsianOption = true;
                if (asianOption.Fixings.TryGetValue(baseMarket.ReferenceDate, out var dd))
                {
                    asianOption.Fixings[nextDay] = dd;
                }
                else if (baseMarket.StockPrices != null && asianOption.UnderlyingTickers != null
                   && asianOption.UnderlyingTickers.Length > 0
                   && baseMarket.StockPrices.TryGetValue(asianOption.UnderlyingTickers[0], out dd))
                {
                    asianOption.Fixings[baseMarket.ReferenceDate] = dd;
                    if (!PS.Config.Is润和)
                    {
                        asianOption.Fixings[nextDay] = dd;
                    }
                }
            }

            if (optionTrade.Instrument is Qdp.Pricing.Library.Common.Base.OptionBase optionBase)
            {
                if (PS.Config.Is润和)
                {
                    var optionDayCount = CalculatorHelper.GetTradeDayCount();
                    var timeToMaturityDays = double.NaN;
                    if (isAsianOption)
                    {
                        timeToMaturityDays = TradeCalcHelper.CalculateTTMDays(nextDay, optionTrade.MaturityDate.DateTime, 0, false, serverDateTime: nextDay.AddHours(15));
                    }
                    else
                    {
                        //当天有夜盘，并且当天还没有进入夜盘（以晚上9点为判断标准），DeltaT+1按照当天晚上9点来计算，否则按照下一个工作日早晨9点来计算
                        //如果当天时节假日，则按照下一个工作日早晨9点来计算
                        //ToDo: 关于长假，虽然品种有夜盘，但是放假前一天晚上是没有夜盘，DeltaT+1需要用下一个工作日的早晨9点来计算的逻辑还未实现
                        if (variety.HasNightMarket && DateTime.Now.Hour < 21 && !QdpCalendarHelper.IsHoliday(baseMarket.ReferenceDate))
                        {
                            timeToMaturityDays = TradeCalcHelper.CalculateTTMDays(baseMarket.ReferenceDate.DateTime, optionTrade.MaturityDate.DateTime, 0, false, serverDateTime: baseMarket.ReferenceDate.DateTime.AddHours(21));
                        }
                        else
                        {
                            timeToMaturityDays = TradeCalcHelper.CalculateTTMDays(nextDay, optionTrade.MaturityDate.DateTime, 0, false, serverDateTime: nextDay.AddHours(9));
                        }
                    }

                    optionBase.PricingToverride = QdpCalendarHelper.CalculateTFromDays(timeToMaturityDays, optionDayCount, optionTrade.StartDate);
                }
                else
                {
                    optionBase.PricingToverride = double.NaN;
                }

                optionBase.CommodityFuturesPreciseTimeMode = false;
            }

            var result = optionTrade.CalculateRisks(market, PricingRequest.Delta, engine, parameters);

            if (result.Succeeded)
            {
                if (PS.Config.Company == Configuration.CompanyEnum.国元固收)
                {
                    return result.Delta / 10000;
                }
                else
                {
                    return result.Delta;
                }
            }

            return null;
        }

        /// <summary>
        /// 现价和执行价非常接近时QDP计算雪球凤凰时会非常慢而且吃内存,故而需要优化
        /// !!!注意不要传入相对行权价
        /// </summary>
        static void OptimizeSpotPrice(ref double spotPrice, double strike)
        {
            if (spotPrice == 0)
            {
                if (Math.Abs(strike) < 1e-5)
                {
                    spotPrice = strike;
                }
            }
            else if (Math.Abs(1 - (strike / spotPrice)) < 1e-5)
            {
                spotPrice = strike;
            }
        }

        #endregion

        #region----香草期权----

        /// <summary>
        /// 计算香草期权的估值与风险
        /// </summary>
        public static TradeValueResult GetVanillaOptionValue(MarketProxy marketProxy, OptionCalcParam<VanillaOptionTradeParam> calcParam)
        {
            if (marketProxy is null)
            {
                throw new ArgumentNullException(nameof(marketProxy));
            }

            if (calcParam is null)
            {
                throw new ArgumentNullException(nameof(calcParam));
            }

            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var optionTrade = QdpTradeBuilder.GetVanillaOptionTrade(calcParam.TradeParam);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);

            var parameters = helper.GetValuationParameters();

            var option = optionTrade.Instrument as VanillaOption;
            var factory = OptionEngineFactory.GetEngineFactory("VanillaOption");
            var engine = factory.GetEngine(calcParam.engineName, option.Exercise);

            marketProxy.Trace?.WriteData(optionTrade, "QDP 香草");

            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);

            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)//?不记得这个算法调整为啥有些地方加了,有些地方没加了,所以不要把这个逻辑移动到 ConvertTradeValueResultOfCompany 里
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }

                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam.TradeParam.tradeType);

                return tr;
            }

            return null;
        }

        #endregion

        #region----彩虹期权----

        /// <summary>
        /// 彩虹期权
        /// </summary>
        public static TradeValueResult GetRainbowOptionValue(MarketProxy marketProxy, OptionCalcParam<RainbowOptionTradeParam> calcParam)
        {
            if (marketProxy is null)
            {
                throw new ArgumentNullException(nameof(marketProxy));
            }

            if (calcParam is null)
            {
                throw new ArgumentNullException(nameof(calcParam));
            }

            var tp = calcParam.TradeParam;

            //这里需要优化
            if (calcParam.volSurfaceNames == null || calcParam.volSurfaceNames.Length != 2)
            {
                throw new Exception("缺少波动率");
            }

            var optionTrade = QdpTradeBuilder.GetRainbowOptionTrade(tp);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);

            //设置标的价格
            var count = Math.Min(calcParam.underlyingTickers.Length, calcParam.spotPrices.Length);
            for (var i = 0; i < count; ++i)
            {
                marketProxy.SetStockPrice(calcParam.underlyingTickers[i], calcParam.spotPrices[i]);
            }

            //设置correlation
            marketProxy.SetCorrelation(calcParam.underlyingTickers, tp.correlation);

            string dividendCurveName = null;
            OptionValuationParameters parameters;
            if (ConsGlobal.InstrumentType.CalcTypeIsStock(tp.underlyingInstrumentType))
            {
                //设置DividendCurve
                dividendCurveName = Guid.NewGuid().ToString();
                var dividendCurve = CalculatorHelper.CreateConstantRiskFreeCurve(dividendCurveName, tp.dividendRate);
                marketProxy.SetYieldCurve(dividendCurveName, dividendCurve);
                parameters = new OptionValuationParameters(
                    marketProxy.DiscountCurveName,
                    new string[] { dividendCurveName, dividendCurveName }, calcParam.volSurfaceNames,
                    new string[] { calcParam.underlyingTickers[0] + "_" + calcParam.underlyingTickers[1] }, null);
            }
            else
            {
                parameters = new OptionValuationParameters(
                    marketProxy.DiscountCurveName,
                    new string[] { MarketProxy.ConstantZeroCurve, MarketProxy.ConstantZeroCurve },
                    calcParam.volSurfaceNames,
                    new string[] { calcParam.underlyingTickers[0] + "_" + calcParam.underlyingTickers[1] }, null);
            }

            marketProxy.Trace?.WriteData(optionTrade, "QDP 彩虹");

            var riskResult = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, null, parameters);

            if (!string.IsNullOrEmpty(dividendCurveName))
            {
                marketProxy.RemoveYieldCurve(dividendCurveName);
            }

            if (riskResult.Succeeded)
            {
                var ret = new TradeValueResult
                {
                    UnderlyingCode = calcParam.underlyingTickers[0],
                    Pv = riskResult.Pv,
                    Delta = riskResult.asset1Delta,
                    Gamma = riskResult.asset1Gamma,
                    Vega = riskResult.asset1Vega,
                    CalendarDayTheta = riskResult.Theta,
                    TradingDayTheta = riskResult.ThetaPnL,
                    Rho = riskResult.Rho,
                    DeltaCash = riskResult.DeltaCash,
                    GammaCash = riskResult.GammaCash,
                    Vol = riskResult.PricingVol,

                    UnderlyingCode2 = calcParam.underlyingTickers[1],
                    Delta2 = riskResult.asset2Delta,
                    Gamma2 = riskResult.asset2Gamma,
                    DeltaCash2 = riskResult.asset2DeltaCash,
                    GammaCash2 = riskResult.asset2GammaCash,
                    Vega2 = riskResult.asset2Vega,
                    CrossGamma = riskResult.crossGamma,
                    CrossVogga = riskResult.crossVomma,
                    CorrVega = riskResult.correlationVega,
                    RoundedPv = OtcFormatHelper.FormatValue(riskResult.Pv / optionTrade.Notional, 2) * optionTrade.Notional,
                    TimeValue = riskResult.TimeValue
                };
                ValueCalculator.ConvertTradeValueResultOfCompany(ret, calcParam?.TradeParam?.tradeType);
                return ret;
            }

            return null;
        }

        #endregion

        #region----亚式期权----

        /// <summary>
        /// 亚式期权
        /// </summary>
        public static TradeValueResult GetAsianOptionValue(MarketProxy marketProxy, OptionCalcParam<AsianOptionTradeParam> calcParam)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var optionTrade = QdpTradeBuilder.GetAsianOptionTrade(calcParam.TradeParam);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var parameters = helper.GetValuationParameters();

            var option = optionTrade.Instrument as AsianOption;
            var factory = OptionEngineFactory.GetEngineFactory("AsianOption");
            var engine = factory.GetEngine(calcParam.engineName, option.Exercise, calcParam.TradeParam.payoffType, option, calcParam.TradeParam.strikeStyle);
            var pricingRequest = calcParam.pricingRequest;
            if (option.AsianType == AsianType.EnhancedArithmeticAverage)
            {
                pricingRequest = QdpPricingRequest.UnionBaiscGreeks(calcParam.pricingRequest);

                if ((calcParam.pricingRequest & PricingRequest.TimeValue) == PricingRequest.TimeValue)
                {
                    pricingRequest |= PricingRequest.TimeValue;
                }
            }

            marketProxy.Trace?.WriteData(optionTrade, "QDP 亚式");

            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, pricingRequest, engine, parameters);

            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional,
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }
                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }

            return null;
        }

        /// <summary>
        /// 亚式合成价差期权
        /// </summary>
        public static TradeValueResult GetAsianSSpreadOptionValue(MarketProxy marketProxy, OptionCalcParam<AsianOptionTradeParam> calcParam)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var optionTrade = QdpTradeBuilder.GetAsianSSpreadOptionTrade(calcParam.TradeParam);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var parameters = helper.GetValuationParameters();
            var engine = new AnalyticalAsianSyntheticNormalSpreadOptionEngine();

            marketProxy.Trace?.WriteData(optionTrade, "QDP 亚式合成价差");

            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);

            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }
                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }

            return null;
        }

        #endregion

        #region----障碍期权----

        /// <summary>
        /// 障碍期权
        /// </summary>
        public static TradeValueResult GetBarrierOptionValue(MarketProxy marketProxy, OptionCalcParam<BarrierOptionTradeParam> calcParam)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var tp = calcParam.TradeParam;

            //如果用户自定义的观察日就是每天观察，则忽略自定义观察日
            var observationDates = CalendarImpl.Get("chn").BizDaysBetweenDatesExcluStartDay(tp.startDate, tp.exerciseDate)
                .Union(new[] { tp.exerciseDate }).ToArray();
            var barrierObservationDates = QdpHelper.ParseObservationDate(tp.observationDateStr);
            if (barrierObservationDates != null &&
                (barrierObservationDates.Count(d => d >= observationDates.First() && d <= observationDates.Last()) == observationDates.Length))
            {
                tp.observationDateStr = null;
            }

            var pricingRequest = calcParam.pricingRequest;
            if (!string.IsNullOrWhiteSpace(calcParam.TradeParam.observationDateStr))
            {
                pricingRequest = QdpPricingRequest.UnionBaiscGreeks(calcParam.pricingRequest);
            }

            var optionTrade = QdpTradeBuilder.GetBarrierOptionTrade(tp);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var parameters = helper.GetValuationParameters();
            var option = optionTrade.Instrument as BarrierOption;
            var factory = OptionEngineFactory.GetEngineFactory("BarrierOption");
            var engine = factory.GetEngine(calcParam.engineName, option.Exercise, option,
                !string.IsNullOrWhiteSpace(tp.observationDateStr), calcParam.quadratureFastMode);

            marketProxy.Trace?.WriteData(optionTrade, "QDP 障碍");

            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, pricingRequest, engine, parameters);

            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional,
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }

                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }

            return null;
        }

        #endregion

        #region----二元期权----

        private static BinaryOptionReplicationStrategy ConvertReplicationStrategy(string replicationStrategy)
        {
            switch (replicationStrategy)
            {
                case "Down":
                    return BinaryOptionReplicationStrategy.Down;
                case "Middle":
                    return BinaryOptionReplicationStrategy.Middle;
                default:
                    return BinaryOptionReplicationStrategy.None;
            }
        }

        /// <summary>
        /// 二元期权
        /// </summary>
        public static TradeValueResult GetBinaryOptionValue(MarketProxy marketProxy, OptionCalcParam<BinaryOptionTradeParam> calcParam)
        {
            if (marketProxy is null)
            {
                throw new ArgumentNullException(nameof(marketProxy));
            }

            if (calcParam is null)
            {
                throw new ArgumentNullException(nameof(calcParam));
            }

            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var tp = calcParam.TradeParam;

            var optionTrade = QdpTradeBuilder.GetBinaryOptionTrade(tp);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var replicationStrategy = ConvertReplicationStrategy(tp.binaryOptionReplicationStrategy);
            var parameters = helper.GetValuationParameters();

            var option = optionTrade.Instrument as BinaryOption;
            var factory = OptionEngineFactory.GetEngineFactory("BinaryOption");
            var engine = factory.GetEngine(calcParam.engineName, option.Exercise,
                (tp.replicationShiftSize <= 0) ? option.Strike * 0.01 : tp.replicationShiftSize, replicationStrategy,
                !string.IsNullOrWhiteSpace(tp.observationDateStr), option.RebateAnnualizedAtKO);

            marketProxy.Trace?.WriteData(optionTrade, "QDP 二元");

            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);

            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional,
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }

                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }
            return null;
        }

        #endregion

        #region----价差期权----

        /// <summary>
        /// 价差期权
        /// </summary>
        public static TradeValueResult GetSpreadOptionValue(MarketProxy marketProxy, OptionCalcParam<SpreadOptionTradeParam> calcParam)
        {
            var tp = calcParam.TradeParam;

            if (calcParam.volSurfaceNames == null)
            {
                tp.volSurfaceNames = calcParam.underlyingTickers.Select(x => x.GenerateVolSurfaceKey()).ToArray();
            }

            var optionTrade = QdpTradeBuilder.GetSpreadOptionTrade(tp);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);

            //设置标的价格
            var count = Math.Min(calcParam.underlyingTickers.Length, calcParam.spotPrices.Length);
            for (var i = 0; i < count; ++i)
            {
                marketProxy.SetStockPrice(calcParam.underlyingTickers[i], calcParam.spotPrices[i]);
            }

            //设置correlation
            marketProxy.SetCorrelation(new string[] { calcParam.underlyingTickers[0], calcParam.underlyingTickers[1] }, tp.correlations[0]);
            if (calcParam.underlyingTickers.Length >= 3)
            {
                marketProxy.SetCorrelation(new string[] { calcParam.underlyingTickers[0], calcParam.underlyingTickers[2] }, tp.correlations[1]);
                marketProxy.SetCorrelation(new string[] { calcParam.underlyingTickers[1], calcParam.underlyingTickers[2] }, tp.correlations[2]);
                if (calcParam.underlyingTickers.Length >= 4)
                {
                    marketProxy.SetCorrelation(new string[] { calcParam.underlyingTickers[0], calcParam.underlyingTickers[3] }, tp.correlations[3]);
                    marketProxy.SetCorrelation(new string[] { calcParam.underlyingTickers[1], calcParam.underlyingTickers[3] }, tp.correlations[4]);
                    marketProxy.SetCorrelation(new string[] { calcParam.underlyingTickers[2], calcParam.underlyingTickers[3] }, tp.correlations[5]);
                }
            }

            var parameters = QdpTradeBuilder.GetParametersForSpreadOption(calcParam.underlyingTickers, marketProxy.DiscountCurveName, calcParam.volSurfaceNames);

            var factory = OptionEngineFactory.GetEngineFactory("SpreadOption");
            var engine = factory.GetEngine(calcParam.engineName);

            marketProxy.Trace?.WriteData(optionTrade, "QDP 价差");

            var riskResult = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);

            if (riskResult.Succeeded)
            {
                var valueResult = new TradeValueResult
                {
                    Pv = riskResult.Pv,
                    Delta = riskResult.asset1Delta,
                    Gamma = riskResult.asset1Gamma,
                    Vega = riskResult.asset1Vega,
                    CalendarDayTheta = riskResult.Theta,
                    TradingDayTheta = riskResult.ThetaPnL,
                    Rho = riskResult.Rho,
                    DeltaCash = riskResult.DeltaCash,
                    GammaCash = riskResult.GammaCash,
                    Vol = riskResult.PricingVol,

                    Delta2 = riskResult.asset2Delta,
                    Gamma2 = riskResult.asset2Gamma,
                    DeltaCash2 = riskResult.asset2DeltaCash,
                    GammaCash2 = riskResult.asset2GammaCash,
                    Vega2 = riskResult.asset2Vega,

                    Delta3 = riskResult.asset3Delta,
                    Gamma3 = riskResult.asset3Gamma,
                    DeltaCash3 = riskResult.asset3DeltaCash,
                    GammaCash3 = riskResult.asset3GammaCash,
                    Vega3 = riskResult.asset3Vega,

                    Delta4 = riskResult.asset4Delta,
                    Gamma4 = riskResult.asset4Gamma,
                    DeltaCash4 = riskResult.asset4DeltaCash,
                    GammaCash4 = riskResult.asset4GammaCash,
                    Vega4 = riskResult.asset4Vega,

                    CrossGamma = riskResult.crossGamma,
                    CrossVogga = riskResult.crossVomma,
                    CorrVega = riskResult.correlationVega,

                    RoundedPv = OtcFormatHelper.FormatValue(riskResult.Pv / optionTrade.Notional, 2) * optionTrade.Notional,
                    TimeValue = riskResult.TimeValue,
                    UnderlyingCode = calcParam.underlyingTickers[0],
                    UnderlyingCode2 = calcParam.underlyingTickers[1]
                };
                if (calcParam.underlyingTickers.Length > 2)
                {
                    valueResult.UnderlyingCode3 = calcParam.underlyingTickers[2];
                }
                if (calcParam.underlyingTickers.Length > 3)
                {
                    valueResult.UnderlyingCode4 = calcParam.underlyingTickers[3];
                }

                ValueCalculator.ConvertTradeValueResultOfCompany(valueResult, calcParam?.TradeParam?.tradeType);
                return valueResult;
            }

            return null;
        }

        #endregion

        #region----合成价差期权----

        /// <summary>
        /// 合成价差期权
        /// </summary>
        public static TradeValueResult GetSSpreadOptionValue(MarketProxy marketProxy, OptionCalcParam<SSpreadOptionTradeParam> calcParam)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var optionTrade = QdpTradeBuilder.GetSSpreadOptionTrade(calcParam.TradeParam);

            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);

            var parameters = helper.GetValuationParameters();
            var option = optionTrade.Instrument as VanillaOption;
            var factory = OptionEngineFactory.GetEngineFactory("SynthticNormalSpreadOption");
            var engine = factory.GetEngine(calcParam.engineName, option.Exercise);

            marketProxy.Trace?.WriteData(optionTrade, "QDP 合成价差");

            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);

            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional,
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }
                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }

            return null;
        }

        /// <summary>
        /// 合成价差期权
        /// </summary>
        public static double[] CalcSSpreadCrossGammas(MarketProxy marketProxy, OptionCalcParam<SSpreadOptionTradeParam> calcParam, double[] coefficients)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var optionTrade = QdpTradeBuilder.GetSSpreadOptionTrade(calcParam.TradeParam);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var parameters = helper.GetValuationParameters();
            marketProxy.Trace?.WriteData(optionTrade, "QDP 合成价差 CrossGammas");
            var result = optionTrade.CalcCrossGammas(marketProxy.QdpMarket, parameters);
            if (result == null)
            {
                return null;
            }

            var crossGammas = new List<double>();

            // 先获取返回的结果矩阵中的对角线上的元素，对应的是每个标的的Gamma
            for (var i = 0; i < coefficients.Length; ++i)
            {
                crossGammas.Add(result[i, i]);
            }

            // 再获取两两对应的Cross Gamma
            for (var i = 0; i < coefficients.Length - 1; ++i)
            {
                for (var j = i + 1; j < coefficients.Length; ++j)
                {
                    crossGammas.Add(result[i, j]);
                }
            }

            return crossGammas.ToArray();
        }

        #endregion

        #region ----双鲨期权----

        public static TradeValueResult GetDoubleSharkFinOptionValue(MarketProxy marketProxy, OptionCalcParam<DoubleSharkFinOptionTradeParam> calcParam)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var tp = calcParam.TradeParam;

            //如果用户自定义的观察日就是每天观察，则忽略自定义观察日            
            var observationDates = CalendarImpl.Get("chn").BizDaysBetweenDatesExcluStartDay(tp.startDate, tp.exerciseDate)
                .Union(new[] { tp.exerciseDate }).ToArray();
            var barrierObservationDates = QdpHelper.ParseObservationDate(tp.observationDateStr);
            if (barrierObservationDates != null &&
                (barrierObservationDates.Count(d => d >= observationDates.First() && d <= observationDates.Last()) == observationDates.Length))
            {
                tp.observationDateStr = null;
            }

            var optionTrade = QdpTradeBuilder.GetDoubleSharkFinOptionTrade(tp);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var parameters = helper.GetValuationParameters();
            var option = optionTrade.Instrument as DoubleSharkFinOption;
            var factory = OptionEngineFactory.GetEngineFactory("DoubleSharkFinOption");
            var engine = factory.GetEngine(calcParam.engineName, option.Exercise, option, false
                , !string.IsNullOrWhiteSpace(tp.observationDateStr), calcParam.quadratureFastMode);
            marketProxy.Trace?.WriteData(optionTrade, "QDP 双鲨");
            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);
            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional,
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }
                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }

            return null;
        }

        #endregion

        #region ----凤凰期权----

        public static TradeValueResult GetAutocallOptionValue(MarketProxy marketProxy, OptionCalcParam<AutocallOptionTradeParam> calcParam)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var optionTrade = QdpTradeBuilder.GetAutocallOptionTrade(calcParam.TradeParam);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var parameters = helper.GetValuationParameters();
            var option = optionTrade.Instrument as AutoCall;
            var factory = OptionEngineFactory.GetEngineFactory("AutoCall");
            var engine = factory.GetEngine(calcParam.engineName, option.Exercise, calcParam.quadratureFastMode);

            marketProxy.Trace?.WriteData(optionTrade, "QDP 凤凰");

            try
            {
                var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);

                if (result.Succeeded)
                {
                    var tr = new TradeValueResult(result)
                    {
                        UnderlyingCode = helper.underlyingTicker,
                        RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional
                    };

                    if (calcParam.CalcDeltaT1)
                    {
                        tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                    }
                    if (PS.Config.Company == Configuration.CompanyEnum.天风)
                    {
                        tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                    }
                    ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                    return tr;
                }
            }
            catch (Exception ex)
            {
                using var db = DbContextFactory.GetYLDbContext();
                if (int.TryParse(calcParam.TradeParam.tradeId.Split('_')[1], out var t))
                {
                    var tradeNumber = db.trade.FirstOrDefault(l => l.id == t)?.TradeNumber;
                    throw new Exception($"交易编号:{tradeNumber},错误信息：{ex.Message}");
                }
                else
                {
                    //todo
                }
            }
            return null;
        }

        #endregion

        #region ----雪球期权----

        public static TradeValueResult GetSnowballOptionValue(MarketProxy marketProxy, OptionCalcParam<SnowballOptionTradeParam> calcParam)
        {
            SimpleSnowball option;
            AnnualizedPremiumSnowball annualOption = null;

            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var optionTrade = QdpTradeBuilder.GetSnowballOptionTrade(calcParam.TradeParam);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            if (optionTrade.Instrument is AnnualizedPremiumSnowball snowball)
            {
                option = annualOption = snowball;
                annualOption.AnnualizedPremium = calcParam.TradeParam.annualizedPremiumRate ?? 0;
            }
            else
            {
                option = optionTrade.Instrument as SimpleSnowball;
            }

            var parameters = helper.GetValuationParameters();
            var factory = OptionEngineFactory.GetEngineFactory("SnowBall");
            var engine = factory.GetEngine(calcParam.engineName, option.Exercise, calcParam.quadratureFastMode);

            marketProxy.Trace?.WriteData(optionTrade, "QDP 雪球");

            IPricingResult result;

            if (annualOption == null)
            {
                //加速方法定价的结果没有考虑deltacash和gammacash,所以只有定价可以使用
                if (calcParam.calcScenario == Enums.CalcScenarioEnum.Pricing && engine is QuadAutoCallEngine engine1)
                {
                    //普通雪球期权可以采用加速方法定价
                    var market = SnowballTrade.ConvertToMarketCondition(optionTrade.TradeId, marketProxy.QdpMarket, parameters);
                    var gridSnapshot = new QuadSnowballGridSnapshot(option, market, engine1);
                    result = gridSnapshot.Calculate(market.SpotPrices.Value.Values.First()
                        , option.BarrierStatus == BarrierStatus.KnockedIn, calcParam.pricingRequest, rebuildGrid: false);
                }
                else
                {
                    result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);
                }
            }
            else
            {
                result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);
            }

            if (result != null && result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }

                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }

            return null;
        }

        /// <summary>
        /// 专业版雪球
        /// </summary>
        /// <param name="marketProxy"></param>
        /// <param name="calcParam"></param>
        /// <returns></returns>
        public static TradeValueResult GetSnowballSpecialistOptionValue(MarketProxy marketProxy, OptionCalcParam<SnowballSpecialistOptionTradeParam> calcParam, OptionValueCalcRequest request)
        {
            return new TradeValueResult { Succeeded = false, ErrorMessage = "不支持专业版雪球" };

            //var tradeParams = calcParam.TradeParam;

            //using var wrapper = new CxxCalcApi();

            //// 敲入观察日
            //var koParams = tradeParams.koObservationDateStr.Split(";");
            //var koObsDateStr = koParams[0];
            //var koObsDates = koObsDateStr.Split(",").Select(g => new Date(DateTime.Parse(g))).ToArray();
            //var koBarriers = koParams[1].Split(",").Select(g => double.Parse(g)).ToArray();
            //var koCoupons = koParams[2].Split(",").Select(g => double.Parse(g)).ToArray();

            //var kiBarrier = tradeParams.kiBarrier;
            //var strike = tradeParams.strike;
            //if (!tradeParams.isMoneynessOption)
            //{
            //    //转为相对价格比例
            //    koBarriers = koBarriers.Select(g => g / tradeParams.initialSpotPrice).ToArray();
            //    kiBarrier /= tradeParams.initialSpotPrice;
            //    strike /= tradeParams.initialSpotPrice;
            //}

            //// 计算票息年化系数(外部有不同的计算方式)
            //var dayCount = tradeParams.couponDayCount.ToDayCountImpl();
            //var koFractions = koObsDateStr.Split(",").Select(g =>
            //{
            //    var koObsDate = DateTime.Parse(g);
            //    var koFraction = YLErp.QdpModule.QdpHelper.AnnualizeFactor(tradeParams.startDate, koObsDate, dayCount);
            //    return koFraction;
            //}).ToArray();

            //// 计算入参
            //var calcIn = new CalcIn()
            //{
            //    // 市场（日历）名称，如China
            //    market = "chn",
            //    // 开始日期
            //    startDate = tradeParams.startDate.ToString(),
            //    // 估值日期
            //    valueDate = marketProxy.ValueDate.ToString("yyyy-MM-dd"),
            //    // 5是向上敲出的雪球，6是向下敲出的雪球??
            //    barrierType = tradeParams.optionType == OptionType.Call ? CxxCalcLib.BarrierType.UP_OUT_DOWN_IN : CxxCalcLib.BarrierType.UP_OUT_DOWN_IN,
            //    // 期初价格
            //    initialSpot = tradeParams.initialSpotPrice,
            //    // 敲出观察日列表，以逗号分隔
            //    koObsDateStr = koObsDateStr,
            //    // 敲出障碍价格列表，与敲出观察日对应
            //    koBarriers = koBarriers,
            //    // 敲出票息列表??
            //    koCoupons = koCoupons,
            //    // 敲出票息的年化系数列表
            //    koFractions = koFractions,
            //    // 剩余未观察的敲出观察日个数
            //    activeKoObsCount = koObsDates.Where(g => g > tradeParams.startDate).Count(),
            //    // 敲出增强收益的参与率，无增强收益填0??
            //    koPayoffParticipation = 0,
            //    // 敲入障碍价格
            //    kiBarrier = kiBarrier,
            //    // 敲入后的行权价
            //    kiStrike = strike,
            //    // 是否仅在到期日进行敲入观察，否则为每日观察
            //    kiObsOnlyAtMaturity = tradeParams.KIObservationType == KIObservationType.OnlyEndDate,
            //    // 敲入后的期权参与率??
            //    kiParticipationRate = tradeParams.KIParticipationRate,
            //    // 红利票息
            //    maturityCoupon = tradeParams.coupon,
            //    // 保本比例，如0.8表示敲入后亏损封顶20%
            //    protectionRatio = tradeParams.PrincipalProtectionRate,
            //    // 初始预付金比例
            //    initialMarginRatio = tradeParams.PrepaymentRatio,
            //    // 预付金利率
            //    marginInterestRate = tradeParams.PrepaymentInterestRate,
            //    // 数量??
            //    amount = tradeParams.notional,
            //    // 是否已敲入
            //    isKnockedIn = false,
            //    // 一组标的资产价格，每个价格都是一个情景
            //    spots = new double[] { tradeParams.initialSpotPrice },
            //    // 情景个数??
            //    scenarioCount = 1,
            //    // 无风险利率
            //    r = tradeParams.riskFreeRate,
            //    // 分红率
            //    q = tradeParams.dividendRate,
            //    // 波动率
            //    v = request.vols[0],
            //    // 计算指标，逗号隔开
            //    greekType = "PV,DELTA,GAMMA,VEGA,RHO,THETA"
            //};
            //var result1 = wrapper.CalcPlatform_SnowballScenario(calcIn);
            //var result = result1.Values.FirstOrDefault();
            //return new TradeValueResult(true)
            //{
            //    Pv = result.PV,
            //    Delta = result.DELTA,
            //    Gamma = result.GAMMA,
            //    Vega = result.VEGA,
            //    Rho = result.RHO,
            //    CalendarDayTheta = result.THETA,
            //    TradingDayTheta = result.THETA,
            //};
        }
        #endregion

        #region ----气囊结构----

        /// <summary>
        /// 气囊结构
        /// </summary>
        public static TradeValueResult GetAirbagOptionValue(MarketProxy marketProxy, OptionCalcParam<AirBagOptionTradeParam> calcParam)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var optionTrade = QdpTradeBuilder.GetAirbagOptionTrade(calcParam.TradeParam);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var parameters = helper.GetValuationParameters();
            var option = optionTrade.Instrument as Airbag;
            var engine = new AnalyticalAirbagReplicationEngine();

            marketProxy.Trace?.WriteData(optionTrade, "QDP 气囊");

            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);
            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }
                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }

            return null;
        }

        #endregion

        #region ----收益增强结构----

        public static TradeValueResult GetUnderlyingEnhanceValue(MarketProxy marketProxy, OptionCalcParam<UnderlyingEnhanceTradeParam> calcParam)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var optionTrade = QdpTradeBuilder.GetUnderlyingEnhanceTrade(calcParam.TradeParam);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var parameters = helper.GetValuationParameters();
            var option = optionTrade.Instrument as UnderlyingPayoffEnhance;
            var engine = new AnalyticalUnderlyingPayoffEnhanceEngine(calcAsOptions: true);

            marketProxy.Trace?.WriteData(optionTrade, "QDP 收益增强");

            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);

            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }
                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }

            return null;
        }

        #endregion

        #region----区间累积----

        public static TradeValueResult GetRangeAccrualValue(MarketProxy marketProxy, OptionCalcParam<RangeAccrualTradeParam> calcParam)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            var optionTrade = QdpTradeBuilder.GetRangeAccrualTrade(calcParam.TradeParam);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var parameters = helper.GetValuationParameters();
            var option = optionTrade.Instrument as RangeAccrual;
            var factory = OptionEngineFactory.GetEngineFactory("RangeAccrual");
            var engine = factory.GetEngine(calcParam.engineName, option.Exercise);

            marketProxy.Trace?.WriteData(optionTrade, "QDP 区间累积");

            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);

            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / optionTrade.Notional, 2) * optionTrade.Notional,
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }
                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }

            return null;
        }

        #endregion

        #region ----累计期权----

        /// <summary>
        /// 
        /// </summary>
        /// <param name="marketProxy"></param>
        /// <param name="calcParam"></param>
        /// <param name="notional">累计期权交易的notional，和param里面的notional不同，param里面的notional代表的是沽购数量</param>
        /// <returns></returns>
        public static TradeValueResult GetAccumulatorOptionValue(MarketProxy marketProxy, OptionCalcParam<AccumulatorOptionTradeParam> calcParam, double notional)
        {
            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam);
            //当到期日和定价日一样，并且当前时间大于3点，ttm传0;qdp里面 ttm等于0和不等于0逻辑处理不一样。
            if (calcParam.TradeParam.exerciseDate.DateTime == marketProxy.ValueDate && DateTime.Now.Hour >= 15)
            {
                calcParam.TradeParam.timeToMaturityDays = 0;
            }
            var optionTrade = QdpTradeBuilder.GetAccumulatorOptionTrade(calcParam.TradeParam);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var parameters = helper.GetValuationParameters();
            IEngine engine;
            if (optionTrade is SegmentedAccumulatorOptionTrade)
            {
                engine = new AnalyticalSegmentedAccumulatorOptionEngine();
            }
            else
            {
                if (calcParam.TradeParam.EarlyTerminate)
                {
                    engine = new QuadAccumulatorOptionEngine();
                }
                else
                {
                    engine = new AnalyticalAccumulatorOptionEngine();
                }
            }

            calcParam.pricingRequest = PricingRequest.Pv | PricingRequest.Delta | PricingRequest.Gamma | PricingRequest.Vega | PricingRequest.Rho | PricingRequest.Theta;

            marketProxy.Trace?.WriteData(optionTrade, "QDP 累计期权");

            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);

            if (result.Succeeded)
            {
                var tr = new TradeValueResult(result)
                {
                    UnderlyingCode = helper.underlyingTicker,
                    RoundedPv = OtcFormatHelper.FormatValue(result.Pv / notional, 2) * notional
                };

                if (calcParam.CalcDeltaT1)
                {
                    tr.DeltaT1 = CalcDeltaT1(optionTrade, marketProxy.QdpMarket, engine, parameters);
                }
                if (PS.Config.Company == Configuration.CompanyEnum.天风)
                {
                    tr.GammaCash = 0.5 * result.Gamma * Math.Pow(calcParam.spotPrices[0] * 0.01, 2);
                }

                ValueCalculator.ConvertTradeValueResultOfCompany(tr, calcParam?.TradeParam?.tradeType);

                return tr;
            }

            return null;
        }

        #endregion

        #region ----现金流----

        public static TradeValueResult GetCashFlowValue(MarketProxy marketProxy, OptionCalcParam<CashFlowTradeParam> calcParam, double stockEqvNotional)
        {
            if (marketProxy is null)
            {
                throw new ArgumentNullException(nameof(marketProxy));
            }

            if (calcParam is null)
            {
                throw new ArgumentNullException(nameof(calcParam));
            }

            calcParam.TradeParam.volSurfaceNames = new string[] { "cashflow_0" };

            //现金流交易在Qdp里的对应的类（Deposit）不接受常量无风险利率作为输入，只能以折现曲线的形式传入定价
            //现金流交易的无风险利率使用market中设置的全局值
            marketProxy.SetYieldCurve(marketProxy.DiscountCurveName,
                QdpHelper.CreateRiskFreeCurve(marketProxy.DiscountCurveName, calcParam.TradeParam.riskFreeRate, marketProxy.CurveDayCount));

            using var helper = new SingleUnderlyingCalcHelper(marketProxy).Prepare(calcParam, true);
            var optionTrade = QdpTradeBuilder.GetCashFlowTrade(calcParam.TradeParam, stockEqvNotional);
            // 添加计算日志
            AddCalculationLog(optionTrade, calcParam.calcScenario, calcParam?.TradeParam?.tradeNumber);
            var discountCurveName = marketProxy.DiscountCurveName ?? MarketProxy.ConstantZeroCurve;
            var parameters = new SimpleCfValuationParameters(discountCurveName, discountCurveName, discountCurveName);
            IEngine engine = new DepositEngine();
            var result = optionTrade.CalculateRisks(marketProxy.QdpMarket, calcParam.pricingRequest, engine, parameters);
            TradeValueResult tradeValue = null;
            if (result.Succeeded)
            {
                tradeValue = new TradeValueResult(result);// { RoundedPv = result.Pv };

                if (calcParam.TradeParam.DepositType == CashflowDepositTypeEnum.资金收益)
                {
                    tradeValue.Pv += stockEqvNotional * calcParam.TradeParam.PrepayRatio * (calcParam.TradeParam.buysell == TradeType.Buy.ToString() ? 1 : -1);
                }
                tradeValue.RoundedPv = tradeValue.Pv;
                ValueCalculator.ConvertTradeValueResultOfCompany(tradeValue, calcParam?.TradeParam?.tradeType);
            }
            return tradeValue;
        }

        #endregion

        #region----自定义交易----
        /// <summary>
        /// 计算自定义交易期权价值
        /// <para>默认取维护的风险值</para>
        /// <para>没维护过风险值且ExternalAPIEnable功能开启时,会调用外部接口计算</para>
        /// </summary>
        /// <param name="valueDate">估值日期</param>
        /// <param name="td">交易</param>
        /// <param name="spotPrice">现价</param>
        /// <param name="isCustomerTrade">是否为自定义交易</param>
        /// <param name="volType">调用外部接口计算时,使用的波动率类型,默认为交易波动率</param>
        /// <param name="volValue">调用外部接口计算时,使用的波动率,该值忽略时使用波动率类型取值</param>   
        /// <returns></returns>
        public static (eod_trade_risk_manual manual, TradeValueResult optionValue) GetManualOptionValue(
            DateTime valueDate, trade td, double spotPrice, double volValue, bool isCustomerTrade, CalcScenarioEnum calcScenario, string volType = "持仓", SettlementTypeEnum settlementType = SettlementTypeEnum.ClosePrice, double overrideVol = double.NaN, bool isSettle = false)
        {
            using var db = DbContextFactory.GetYLDbContext();
            if (volType == "交易")
            {
                volType = "持仓";
            }
            var tradeId = td.id;
            //分类维护的风险数据优先级高于普通的风险数据
            var manual = db.eod_trade_risk_manual.Where(x => (x.ValueDate <= valueDate && isCustomerTrade || x.ValueDate == valueDate) && x.TradeId == tradeId && x.VolType == volType && x.SettlementType == settlementType)
                .OrderByDescending(x => x.ValueDate).FirstOrDefault();
            if (manual == null)
            {
                manual = db.eod_trade_risk_manual.Where(x => (x.ValueDate <= valueDate && isCustomerTrade || x.ValueDate == valueDate) && x.TradeId == tradeId && string.IsNullOrEmpty(x.VolType))
                .OrderByDescending(x => x.ValueDate).FirstOrDefault();
            }
            else
            {
                //如果分类维护的数据不全，通过单一数据补充
                var singleManual = db.eod_trade_risk_manual.Where(x => (x.ValueDate <= valueDate && isCustomerTrade || x.ValueDate == valueDate) && x.TradeId == tradeId && string.IsNullOrEmpty(x.VolType))
                .OrderByDescending(x => x.ValueDate).FirstOrDefault();
                if (singleManual != null)
                {
                    manual.Pv ??= singleManual.Pv;
                    manual.Delta ??= singleManual.Delta;
                    manual.DeltaCash ??= singleManual.DeltaCash;
                    manual.Gamma ??= singleManual.Gamma;
                    manual.GammaCash ??= singleManual.GammaCash;
                    manual.Theta ??= singleManual.Theta;
                    manual.Vega ??= singleManual.Vega;
                    manual.VegaCash ??= singleManual.VegaCash;
                    manual.Rho ??= singleManual.Rho;
                }
            }

            TradeValueResult optionValue = null;

            if (manual == null && isCustomerTrade && PS.Config.ErpElement.ExternalAPIForCustomCalcEnable)
            {
                var apiValue = TradeCalcApiHelper.CalculateCustomizedTrade(valueDate, td, spotPrice, volValue, isSettle, calcScenario, TradeCalcApiHelper.PV, TradeCalcApiHelper.DELTA, TradeCalcApiHelper.GAMMA, TradeCalcApiHelper.VEGA, TradeCalcApiHelper.THETA, TradeCalcApiHelper.RHO);
                if (apiValue.Success)
                {
                    manual = new eod_trade_risk_manual()
                    {
                        ValueDate = valueDate,
                        TradeId = td.id,
                        TradeNumber = td.TradeNumber,
                        Pv = apiValue.Content.Pv,
                        Delta = apiValue.Content.Delta,
                        Gamma = apiValue.Content.Gamma,
                        Vega = apiValue.Content.Vega,
                        Theta = apiValue.Content.Theta,
                        Rho = apiValue.Content.Rho,
                        DeltaCash = apiValue.Content.Delta * spotPrice,
                        GammaCash = apiValue.Content.Gamma * Math.Pow(spotPrice, 2) / 100,
                        VegaCash = apiValue.Content.Vega * spotPrice,
                        Vol = td.Vol,
                    };
                    optionValue = apiValue.Content;
                    optionValue.FromManual = false;
                }
                //抛出异常信息返回前端
                else
                {
                    throw new Exception(apiValue.Msg);
                }
            }
            else
            {
                optionValue = new TradeValueResult { FromManual = true };
                if (manual != null)
                {
                    manual.DeltaCash ??= (manual.Delta * spotPrice);
                    manual.GammaCash ??= (manual.Gamma * Math.Pow(spotPrice, 2) / 100);
                    manual.VegaCash ??= (manual.Vega * spotPrice);

                    optionValue = new TradeValueResult
                    {
                        Pv = manual.Pv ?? 0,
                        RoundedPv = manual.Pv ?? 0,
                        Delta = manual.Delta ?? 0,
                        Gamma = manual.Gamma ?? 0,
                        Vega = manual.Vega ?? 0,
                        TradingDayTheta = manual.Theta ?? 0,
                        CalendarDayTheta = manual.Theta ?? 0,
                        Rho = manual.Rho ?? 0,
                        DeltaCash = manual.DeltaCash ?? 0,
                        GammaCash = manual.GammaCash ?? 0,
                        VegaCash = manual.VegaCash ?? 0,
                        FromManual = true,
                        Vol = manual.Vol ?? 0
                    };
                }
            }

            return (manual, optionValue);
        }

        //如果当天有维护过部分风险值，则直接获取风险值，未维护的风险值部分则通过系统计算
        //系统计算结果和手动维护值合并
        public static void GetOptionValueWithManual(eod_trade_risk_manual manual, TradeValueResult result)
        {
            if (manual != null)
            {
                result.Pv = manual.Pv ?? result.Pv;
                result.RoundedPv = manual.Pv ?? result.RoundedPv;
                result.Delta = manual.Delta ?? result.Delta;
                result.DeltaCash = manual.DeltaCash ?? result.DeltaCash;
                result.Gamma = manual.Gamma ?? result.Gamma;
                result.GammaCash = manual.GammaCash ?? result.GammaCash;
                result.Vega = manual.Vega ?? result.Vega;
                result.TradingDayTheta = manual.Theta ?? result.TradingDayTheta;
                result.CalendarDayTheta = manual.Theta ?? result.CalendarDayTheta;
                result.Rho = manual.Rho ?? result.Rho;
            }
        }

        #endregion

        private static void AddCalculationLog(TradeBase trade, CalcScenarioEnum scenarioEnum, string tradeNumber)
        {
            try
            {
                var option = trade.Instrument as OptionBase;

                // 添加计算日志
                var log = new CalculationLog()
                {
                    CreateTime = DateTime.Now,
                    Scenario = scenarioEnum,
                    LogObject = trade,
                    TradeNumber = tradeNumber,
                    Notional = trade.Notional,
                    Exercise = option?.Exercise.ToString(),
                    OptionType = option?.OptionType.ToString(),
                    TradeDate = trade.TradeDate?.ToString(),
                    MaturityDate = trade.MaturityDate?.ToString(),
                    InitialSpotPrice = option?.InitialSpotPrice.ToString(),
                    Strike = option?.Strike.ToString(),
                };

                ICalculationLogService calcLogService = new CalculationLogService();
                calcLogService.AddLog(log, scenarioEnum);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
    }
}