using Qdp.Pricing.Base.Interfaces;

namespace YLErp.Modules.CalculationModule
{
    /// <summary>
    /// 计算成功以后的结果
    /// </summary>
    public class TradeValueResult
    {
        public TradeValueResult()
        {
            Succeeded = true;
        }

        public TradeValueResult(bool succeeded)
        {
            Succeeded = succeeded;
        }

        public TradeValueResult(IPricingResult result)
        {
            if (result != null)
            {
                Pv = result.Pv;
                Delta = result.Delta;
                Gamma = result.Gamma;
                Vega = result.Vega;
                CalendarDayTheta = result.Theta;
                TradingDayTheta = result.ThetaPnL;
                Rho = result.Rho;
                DeltaCash = result.DeltaCash;
                GammaCash = result.GammaCash;
                VegaCash = result.VegaCash;
                Vol = result.PricingVol;

                DDeltaDVol = result.DDeltaDvol;
                DDeltaDt = result.DDeltaDt;
                DVegaDVol = result.DVegaDvol;
                DVegaDt = result.DVegaDt;
                StoppingTime = result.StoppingTime;
                SA_Delta = result.SA_Delta;
                TimeValue = result.TimeValue;

                Succeeded = result.Succeeded;
                ErrorMessage = result.ErrorMessage;

                PricingT = result.PricingT;
            }
            else
            {
                Succeeded = false;
                ErrorMessage = "空的IPricingResult对象传入";
            }
        }

        public string UnderlyingCode { get; set; }

        public double Pv { get => pv; set => pv = value.Normalize(); }

        public double NPv { get => npv; set => npv = value.Normalize(); }

        /// <summary>
        /// 根据某些机构财务需要，将期权单价保留两位小数之后，再乘以份额得到的总Pv值
        /// </summary>
        public double RoundedPv { get => roundedPv; set => roundedPv = value.Normalize(); }

        public double NRoundedPv { get => nRoundedPv; set => nRoundedPv = value.Normalize(); }

        public TradeValueResultExtend ExtendInfo { get; set; } = new TradeValueResultExtend();

        public double Delta { get => delta; set => delta = value.Normalize(); }

        /// <summary>
        /// 计算申万跨式组合预付金时会用到
        /// </summary>
        internal double DeltaMax { get => deltaMax; set => deltaMax = value.Normalize(); }

        /// <summary>
        /// 亚式Delta
        /// </summary>
        public double SA_Delta { get => sA_Delta; set => sA_Delta = value.Normalize(); }

        /// <summary>
        /// 时间价值
        /// </summary>
        public double TimeValue { get => timeValue; set => timeValue = value.Normalize(); }

        public double Gamma { get => gamma; set => gamma = value.Normalize(); }

        private double _vega;

        public double Vega
        {
            get
            {
                return _vega;
            }
            set
            {
                var temp = value.Normalize();
                if (temp != 0 && VegaCash.Normalize() == 0)
                {
                    VegaCash = SpotPrice.Normalize() * temp;
                }
                _vega = temp;
            }
        }

        public double Rho { get => rho; set => rho = value.Normalize(); }

        public double Vol { get => vol; set => vol = value.Normalize(); }

        public double DeltaCash { get => deltaCash; set => deltaCash = value.Normalize(); }

        public double GammaCash { get => gammaCash; set => gammaCash = value.Normalize(); }

        public double VegaCash { get => vegaCash; set => vegaCash = value.Normalize(); }

        public double DDeltaDVol { get => dDeltaDVol; set => dDeltaDVol = value.Normalize(); }

        public double DDeltaDt { get => dDeltaDt; set => dDeltaDt = value.Normalize(); }

        public double DVegaDVol { get => dVegaDVol; set => dVegaDVol = value.Normalize(); }

        public double DVegaDt { get => dVegaDt; set => dVegaDt = value.Normalize(); }

        public double StoppingTime { get => stoppingTime; set => stoppingTime = value.Normalize(); }

        /// <summary>
        /// 日历日Theta
        /// </summary>
        public double CalendarDayTheta { get => calendarDayTheta; set => calendarDayTheta = value.Normalize(); }

        /// <summary>
        /// 交易日Theta
        /// </summary>
        public double TradingDayTheta { get => tradingDayTheta; set => tradingDayTheta = value.Normalize(); }

        public double Theta
        {
            get
            {
                return BLL.valuedateBLL.SystemDate?.ThetaType != "日历日Theta" ? TradingDayTheta : CalendarDayTheta;
            }
        }

        //----------------------------------------
        // 多标的期权
        //----------------------------------------

        public string UnderlyingCode2 { get; set; }

        public double? Delta2 { get => delta2; set => delta2 = value.Normalize(); }

        public double? Gamma2 { get => gamma2; set => gamma2 = value.Normalize(); }

        public double? Vega2 { get => vega2; set => vega2 = value.Normalize(); }

        public double? DeltaCash2 { get => deltaCash2; set => deltaCash2 = value.Normalize(); }

        public double? GammaCash2 { get => gammaCash2; set => gammaCash2 = value.Normalize(); }
        public double? ThetaCash2 { get => thetaCash2; set => thetaCash2 = value.Normalize(); }

        public double CrossGamma { get => crossGamma; set => crossGamma = value.Normalize(); }

        public double CrossVogga { get => crossVogga; set => crossVogga = value.Normalize(); }

        public double CorrVega { get => corrVega; set => corrVega = value.Normalize(); }


        /// <summary>
        /// 报价 卖
        /// </summary>
        public double TradePriceAsk { get => tradePriceAsk; set => tradePriceAsk = value.Normalize(); }

        /// <summary>
        /// 单价四舍五入后的TradePriceAsk
        /// </summary>
        public double RoundedTradePriceAsk { get => roundedTradePriceAsk; set => roundedTradePriceAsk = value.Normalize(); }

        /// <summary>
        /// 买
        /// </summary>
        public double TradePriceBid { get => tradePriceBid; set => tradePriceBid = value.Normalize(); }

        /// <summary>
        /// 单价四舍五入后的TradePriceBid
        /// </summary>
        public double RoundedTradePriceBid { get => roundedTradePriceBid; set => roundedTradePriceBid = value.Normalize(); }

        /// <summary>
        /// delta手数
        /// </summary>
        public double DeltaInLots { get => deltaInLots; set => deltaInLots = value.Normalize(); }

        public int? UnderlyingId { get; set; }

        public double? Strike { get => strike; set => strike = value.Normalize(); }


        private double? _spotPrice;
        private double? pricingT;
        private double? deltaT1;
        private double? vega4;
        private double? vega3;
        private double? gammaCash4;
        private double? gammaCash3;
        private double? gamma4;
        private double? gamma3;
        private double? deltaCash4;
        private double? deltaCash3;
        private double? delta4;
        private double? delta3;
        private double? strike;
        private double deltaInLots;
        private double roundedTradePriceBid;
        private double tradePriceBid;
        private double roundedTradePriceAsk;
        private double tradePriceAsk;
        private double corrVega;
        private double crossVogga;
        private double crossGamma;
        private double? gammaCash2;
        private double? deltaCash2;
        private double? thetaCash2;
        private double? thetaCash3;
        private double? thetaCash4;
        private double? vega2;
        private double? gamma2;
        private double? delta2;
        private double tradingDayTheta;
        private double calendarDayTheta;
        private double stoppingTime;
        private double dVegaDt;
        private double dVegaDVol;
        private double dDeltaDt;
        private double dDeltaDVol;
        private double vegaCash;
        private double gammaCash;
        private double deltaCash;
        private double vol;
        private double rho;
        private double gamma;
        private double timeValue;
        private double sA_Delta;
        private double deltaMax;
        private double delta;
        private double roundedPv;
        private double nRoundedPv;
        private double pv;
        private double npv;

        public double? SpotPrice
        {
            get { return _spotPrice; }
            set
            {
                var temp = value.Normalize();
                if (temp != 0 && VegaCash.Normalize() == 0)
                {
                    VegaCash = Vega.Normalize() * temp;
                }
                _spotPrice = value;
            }
        }

        public string UnderlyingCode3 { get; set; }

        public string UnderlyingCode4 { get; set; }

        public double? Delta3 { get => delta3; set => delta3 = value.Normalize(); }

        public double? Delta4 { get => delta4; set => delta4 = value.Normalize(); }

        public double? DeltaCash3 { get => deltaCash3; set => deltaCash3 = value.Normalize(); }

        public double? DeltaCash4 { get => deltaCash4; set => deltaCash4 = value.Normalize(); }

        public double? Gamma3 { get => gamma3; set => gamma3 = value.Normalize(); }

        public double? Gamma4 { get => gamma4; set => gamma4 = value.Normalize(); }

        public double? GammaCash3 { get => gammaCash3; set => gammaCash3 = value.Normalize(); }

        public double? GammaCash4 { get => gammaCash4; set => gammaCash4 = value.Normalize(); }

        public double? ThetaCash3 { get => thetaCash3; set => thetaCash3 = value.Normalize(); }
        public double? ThetaCash4 { get => thetaCash4; set => thetaCash4 = value.Normalize(); }
        public double? Vega3 { get => vega3; set => vega3 = value.Normalize(); }

        public double? Vega4 { get => vega4; set => vega4 = value.Normalize(); }

        /// <summary>
        /// T+1日Delta
        /// </summary>
        public double? DeltaT1 { get => deltaT1; set => deltaT1 = value.Normalize(); }

        // 第i+1个标的的delta
        public double GetDelta(int i)
        {
            double? result;
            switch (i)
            {
                case 0:
                    result = Delta;
                    break;
                case 1:
                    result = Delta2;
                    break;
                case 2:
                    result = Delta3;
                    break;
                case 3:
                    result = Delta4;
                    break;
                default:
                    throw new ArgumentException($"不合法的标的索引${i}");
            }

            return double.IsNaN(result ?? 0.0) ? 0.0 : result ?? 0.0;
        }

        public double GetGamma(int i)
        {
            double? result;

            switch (i)
            {
                case 0:
                    result = Gamma;
                    break;
                case 1:
                    result = Gamma2;
                    break;
                case 2:
                    result = Gamma3;
                    break;
                case 3:
                    result = Gamma4;
                    break;
                default:
                    throw new ArgumentException($"不合法的标的索引${i}");
            }

            return double.IsNaN(result ?? 0.0) ? 0.0 : result ?? 0.0;
        }

        public double GetVega(int i)
        {
            double? result;
            switch (i)
            {
                case 0:
                    result = Vega;
                    break;
                case 1:
                    result = Vega2;
                    break;
                case 2:
                    result = Vega3;
                    break;
                case 3:
                    result = Vega4;
                    break;
                default:
                    throw new ArgumentException($"不合法的标的索引${i}");
            }

            return double.IsNaN(result ?? 0.0) ? 0.0 : result ?? 0.0;
        }

        public double GetDeltaCash(int i)
        {
            double? result;

            switch (i)
            {
                case 0:
                    result = DeltaCash;
                    break;
                case 1:
                    result = DeltaCash2;
                    break;
                case 2:
                    result = DeltaCash3;
                    break;
                case 3:
                    result = DeltaCash4;
                    break;
                default:
                    throw new ArgumentException($"不合法的标的索引${i}");
            }

            return double.IsNaN(result ?? 0.0) ? 0.0 : result ?? 0.0;
        }

        public double GetGammaCash(int i)
        {
            double? result;

            switch (i)
            {
                case 0:
                    result = GammaCash;
                    break;
                case 1:
                    result = GammaCash2;
                    break;
                case 2:
                    result = GammaCash3;
                    break;
                case 3:
                    result = GammaCash4;
                    break;
                default:
                    throw new ArgumentException($"不合法的标的索引${i}");
            }

            return double.IsNaN(result ?? 0.0) ? 0.0 : result ?? 0.0;
        }

        //------------------------------------------

        public int TradeId { get; set; }

        public string BuySell { get; set; }

        public bool Succeeded { get; set; }

        public string ErrorMessage { get; set; }

        /// <summary>
        /// 错误原因
        /// </summary>
        internal TradeValueFailReason FailReason { get; set; }

        /// <summary>
        /// 是否来自手动风险维护
        /// </summary>
        internal bool FromManual { get; set; }

        /// <summary>
        /// 预付金
        /// </summary>
        internal double? Margin { get; set; }

        /// <summary>
        /// 设置错误信息,设置后Succeeded变为false
        /// </summary>
        /// <param name="errorMessage"></param>
        public TradeValueResult SetError(string errorMessage)
        {
            Succeeded = false;
            ErrorMessage = errorMessage;
            return this;
        }

        public double? PricingT { get => pricingT; set => pricingT = value.Normalize(); }

        public override string ToString()
        {
            return Succeeded ? $"[{TradeId}]{UnderlyingCode},pv:{Pv}" : ErrorMessage;
        }

        /// <summary>
        /// 是否敲出
        /// </summary>
        public bool IsKnockOut { get; set; } = false;

        /// <summary>
        /// 敲出收益
        /// </summary>
        public double KnockOutPayoff { get; set; }


        /// <summary>
        /// PV* 如果敲出则为 敲出收益KnockOutPayoff，未敲出 则为PV
        /// </summary>
        public double PvContainsKnockOut { get; set; }

        /// <summary>
        /// Delta* 如果敲出则为0  未敲出 则等于Delta
        /// </summary>
        public double DeltaContainsKnockOut { get; set; }


        /// <summary>
        /// Gamma* 如果敲出则为0  未敲出 则等于Delta
        /// </summary>
        public double GammaContainsKnockOut { get; set; }



        /// <summary>
        /// Theta(轧差)
        /// </summary>
        public double ThetaNet { get; set; }



        /// <summary>
        /// Delta_R
        /// </summary>
        public double? Delta_r { get; set; }

        public double? Delta_r_1bp { get; set; }


        public double? Dv01 { get; set; }

        public double? Gamma_r { get; set; }

        public double? Gamma_r_1bp { get; set; }

        public double? Vega_r { get; set; }

        public double? Vega_r_1bp { get; set; }

        public double? Vega_1bp { get; set; }
    }

    public class TradeValueResultExtend
    {
        public double QuotePv { get; set; }

        public double FloatingWinLoss { get; set; }

        public double QuoteFloatingWinLoss { get; set; }

        public double Commission { get; set; }

        public double QuoteCommission { get; set; }

        public double AnnualFee { get; set; }

        public double QuoteAnnualFee { get; set; }

        public double IM { get; set; }

        public double QuoteIM { get; set; }

        public double PFE { get; set; }

        public double QuotePFE { get; set; }

        public double RealPnl { get;set; }
    }


    public enum TradeValueFailReason
    {
        none,

        /// <summary>
        /// 缺少交易数据
        /// </summary>
        missingTrade,

        /// <summary>
        /// 缺少波动率
        /// </summary>
        missingVol
    }
}