using YLErp.BLL;
using YLErp.Configuration;
using YLErp.DBModels.Enums;
using YLErp.DBModels.Helpers;

namespace YLErp.Models
{
    public class TradingRiskParameter
    {
        private double _pv;
        private double _npv;
        private double _tv;
        private double _delta;
        private double _sA_Delta;
        private double _gamma;
        private double _theta;
        private double _vega;
        private double _rho;
        private double _vol;
        private double _ddeltaDt;
        private double _ddeltaDvol;
        private double _dvegaDt;
        private double _dvegaDvol;
        private double _deltaCash;
        private double _gammaCash;
        private double _deltaInLots;
        private double _gammaInLots;
        private double? _deltaPercent;
        private double _tradePrice;
        private double _originalPrincipalSum;
        private double _dailyPnl;
        private double _exercisePnl;
        private double _totalPnl;
        private double _pnlWithHedge;
        private double _totalPnlWithHedge;
        private double _cost;
        private double _accruedTotalPnl;

        public string EncryptId
        {
            get { return Helpers.DataProtectHelper.Encrypt(TradeId); }
        }

        /// <summary>
        /// 对冲波动率
        /// </summary>
        public double? TradeSavedVol { get; set; }

        /// <summary>
        /// 报价单位
        /// </summary>
        public string QuoteUnit { get; set; }

        /// <summary>
        /// 交易日期
        /// </summary>
        public DateTime? TradeDate { get; set; }

        /// <summary>
        /// 成交手数
        /// </summary>
        public double? Lots { get; set; }

        /// <summary>
        /// 持仓手数
        /// </summary>
        public double? LotsNewInfo { get; set; }

        /// <summary>
        /// 客户ID
        /// </summary>
        public int ClientId { get; set; }

        /// <summary>
        /// 客户名称
        /// </summary>
        public string ClientName { get; set; }

        /// <summary>
        /// 品种代码
        /// </summary>
        public string VarietyCode { get; set; }

        /// <summary>
        /// 是否组合标的
        /// </summary>
        internal bool IsSynthetic { get; set; }

        /// <summary>
        /// 组合标的的公式信息
        /// </summary>
        public string SyntheticTipsInfo { get; set; }

        /// <summary>
        /// 标的现价
        /// </summary>
        public double? SpotPrice { get; set; }

        /// <summary>
        /// 期初标的价格
        /// </summary>
        public double? InitSpotPrice { get; set; }

        /// <summary>
        /// 离交易到期日还有几天
        /// </summary>
        public int MaturityDay => ExerciseDate == null ? 999999 : ExerciseDate.Value.Subtract(DateTime.Now.Date).Days;

        /// <summary>
        /// 离系统工作日期差几天
        /// </summary>
        public int MaturityWorkDay => ExerciseDate == null ? 999999 : CalendarBLL.GetNonHolidayDays(ExerciseDate.Value);

        /// <summary>
        /// 行权方式
        /// </summary>
        public string ExerciseModeCn => TradeHelper.GetExerciseModeCn(ExerciseMode);

        public string ExerciseMode { get; set; }

        public string TradeStatus { get; set; }

        public int TradeId { get; set; }

        /// <summary>
        /// (EnumTradeType)交易类型标识
        /// </summary>
        public int TradeFlag { get; set; }

        public bool IsOption { get; set; }

        public int? UnderlyingId { get; set; }

        /// <summary>
        /// 结构类型
        /// </summary>
        public string TradeType { get; set; }

        public string StructureType { get; set; }

        /// <summary>
        /// 是否分组交易
        /// </summary>
        public int IsGroup { get; set; }

        /// <summary>
        /// 看涨看跌
        /// </summary>
        public string CallPut { get; set; }

        /// <summary>
        /// 行权日
        /// </summary>
        public DateTime? ExerciseDate { get; set; }

        /// <summary>
        /// 持仓份额
        /// </summary>
        public double Notional { get; set; }

        /// <summary>
        /// 有效开仓份额
        /// </summary>
        public double OriginalNotional { get; set; }

        /// <summary>
        /// 开仓份额(虚拟)
        /// </summary>
        public double OriginalNotionalV { get; set; }

        /// <summary>
        /// 期权份额
        /// </summary>
        public double? OptionVolume { get; set; }

        /// <summary>
        /// 行权价
        /// </summary>
        public double? Strike { get; set; }

        /// <summary>
        /// 名义本金
        /// </summary>
        public double? StockEqvNotional { get; set; }

        /// <summary>
        /// 是否相对行权价
        /// </summary>
        public string IsMoneynessOption { get; set; }

        /// <summary>
        /// 交易方向
        /// </summary>
        public string BuySell { get; set; }

        /// <summary>
        /// 簿记账户
        /// </summary>
        public int BookId { get; set; }

        /// <summary>
        /// 标的代码
        /// </summary>
        public string UnderlyingCode { get; set; }

        /// <summary>
        /// 标的名称
        /// </summary>
        public string UnderlyingName { get; set; }

        /// <summary>
        /// 涨跌幅
        /// </summary>
        public double? SpotPriceChangePercent { get; set; }

        public double Pv
        {
            get => _pv;
            set => _pv = double.IsNaN(value) ? 0 : value;
        }

        public double NPv
        {
            get => _npv;
            set => _npv = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// 时间价值
        /// </summary>
        public double Tv
        {
            get => _tv;
            set => _tv = double.IsNaN(value) ? 0 : value;
        }

        public double Delta
        {
            get => _delta;
            set => _delta = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// T+1日Delta
        /// </summary>
        internal double? DeltaT1 { get; set; }

        /// <summary>
        /// T+1日Delta(手数)
        /// </summary>
        public double? DeltaT1Lots { get; set; }

        public double SA_Delta
        {
            get => _sA_Delta;
            set => _sA_Delta = double.IsNaN(value) ? 0 : value;
        }

        public double Gamma
        {
            get => _gamma;
            set => _gamma = double.IsNaN(value) ? 0 : value;
        }

        public double Theta
        {
            get => _theta;
            set => _theta = double.IsNaN(value) ? 0 : value;
        }

        public double Vega
        {
            get => _vega;
            set => _vega = double.IsNaN(value) ? 0 : value;
        }

        public double Rho
        {
            get => _rho;
            set => _rho = double.IsNaN(value) ? 0 : value;
        }

        public double Vol
        {
            get => _vol;
            set => _vol = double.IsNaN(value) ? 0 : value;
        }

        public double DdeltaDt
        {
            get => _ddeltaDt;
            set => _ddeltaDt = double.IsNaN(value) ? 0 : value;
        }

        public double DdeltaDvol
        {
            get => _ddeltaDvol;
            set => _ddeltaDvol = double.IsNaN(value) ? 0 : value;
        }

        public double DvegaDt
        {
            get => _dvegaDt;
            set => _dvegaDt = double.IsNaN(value) ? 0 : value;
        }

        public double DvegaDvol
        {
            get => _dvegaDvol;
            set => _dvegaDvol = double.IsNaN(value) ? 0 : value;
        }

        public double DeltaCash
        {
            get => _deltaCash;
            set => _deltaCash = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// 东证独有字段 DeltaCash 限额
        /// </summary>
        public double DeltaCash2 { get; set; }

        public double GammaCash
        {
            get => _gammaCash;
            set => _gammaCash = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// Delta手数
        /// </summary>
        public double DeltaInLots
        {
            get => _deltaInLots;
            set => _deltaInLots = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// 可对冲Gamma手数
        /// </summary>
        public double GammaInLots
        {
            get => _gammaInLots;
            set => _gammaInLots = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// 显示某标的期权持仓的已对冲比例，只在按标的浏览汇总时有意义
        /// 计算方式是：该标的总Delta/期权份额
        /// </summary>
        public double? DeltaPercent
        {
            get => _deltaPercent;
            set => _deltaPercent = value == null || double.IsNaN(value.Value) ? 0 : value;
        }

        /// <summary>
        /// 权利金
        /// </summary>
        public double TradePrice
        {
            get => _tradePrice;
            set => _tradePrice = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// 保底收益总额
        /// </summary>
        public double OriginalPrincipalSum
        {
            get => _originalPrincipalSum;
            set => _originalPrincipalSum = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// 权利金
        /// </summary>
        public double Premium { get; set; }

        public bool IsPremiumRate { get; set; }

        public double DailyPnl
        {
            get => _dailyPnl;
            set => _dailyPnl = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// 行权收益(只有期权有)
        /// </summary>
        public double ExercisePnl
        {
            get => _exercisePnl;
            set => _exercisePnl = double.IsNaN(value) ? 0 : value;
        }

        public double TotalPnl
        {
            get => _totalPnl;
            set => _totalPnl = double.IsNaN(value) ? 0 : value;
        }

        public double TotalPnlWithHedge
        {
            get => _totalPnlWithHedge;
            set => _totalPnlWithHedge = double.IsNaN(value) ? 0 : value;
        }

        public double PnlWithHedge
        {
            get => _pnlWithHedge;
            set => _pnlWithHedge = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// 成本
        /// </summary>
        public double Cost
        {
            get => _cost;
            set => _cost = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// 累积总盈亏
        /// </summary>
        public double AccruedTotalPnl
        {
            get => _accruedTotalPnl;
            set => _accruedTotalPnl = double.IsNaN(value) ? 0 : value;
        }

        /// <summary>
        /// 
        /// </summary>
        public string TradeNumber { get; set; }

        /// <summary>
        /// 场内期权代码
        /// </summary>
        public string ExchangeOptionCode { get; set; }

        //持仓类型 long short
        internal string PositionType { get; set; }

        /// <summary>
        /// 标的资产类型
        /// </summary>
        public string InstrumentType { get; set; }

        /// <summary>
        /// 场内期权价格
        /// </summary>
        public double? ExOptionPrice { get; set; }

        /// <summary>
        /// 分红率
        /// </summary>
        public double? DividendRate { get; set; }

        /// <summary>
        /// 无风险利率
        /// </summary>
        public double? NoRiskRate { get; set; }

        /// <summary>
        /// 用于存储场外交易份额[绝对,轧差]
        /// </summary>
        public double[] Notionals { get; set; }

        /// <summary>
        /// 开仓波动率
        /// </summary>
        public double OpenVol { get; set; }

        /// <summary>
        /// 对冲PV
        /// </summary>
        public double? HedgePv { get; set; }

        /// <summary>
        /// 对冲Delta
        /// </summary>
        public double? HedgeDelta { get; set; }

        /// <summary>
        /// 对冲Delta手数
        /// </summary>
        public double? HedgeDeltaLots { get; set; }

        public List<TradingRiskParameter> viewList { get; set; }

        /// <summary>
        /// 判断是否有持仓
        /// </summary>
        internal bool HasPosition { get; set; }

        /// <summary>
        /// 公司定制
        /// </summary>
        public TradingRiskParameter_Company CompanyObj { get; set; }

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

        /// <summary>
        /// TTM
        /// </summary>
        public double? PricingT { get; set; }

        /// <summary>
        /// Debug
        /// </summary>
        public List<object> Debug { get; set; }

        /// <summary>
        /// 
        /// </summary>
        public TradingRiskParameter AddItem(TradingRiskParameter trp)
        {
            return InnerAddItem(trp);
        }

        private TradingRiskParameter InnerAddItem(TradingRiskParameter trp, int depth = 0)
        {
            if (trp is null)
            {
                return this;
            }

            if (Math.Abs(trp.Notional) > 0)
            {
                trp.HasPosition = HasPosition = true;
            }

            //OptionVolume只记录期权交易的份额
            if (trp.TradeFlag < 1)
            {
                trp.TradeFlag = (int)EnumTradeTypeUtil.GetTradeFlag(trp.TradeType);
            }

            //如果是期权交易，将其份额加入期权总份额
            if (trp.TradeFlag > (int)EnumTradeType.ExchangeOption)
            {
                OptionVolume = OptionVolume.GetValueOrDefault() + trp.Notional;
            }

            //所有标的第一次进来都会满足该条件;
            if (UnderlyingCode == null)
            {
                YieldChain.Helpers.ObjectHelper.MapValues(this, trp, "IsOption", "OptionVolume");

                if (trp.IsSynthetic)
                {
                    SyntheticTipsInfo = synthetic_underlyingBLL.GetUnderlyingTipsInfo(trp.UnderlyingCode);
                }
            }
            else
            {
                TradeType = trp.TradeType;
                StructureType = trp.StructureType;
                IsGroup = trp.IsGroup;
                VarietyCode = trp.VarietyCode?.ToUpperInvariant();
                if (!SpotPriceChangePercent.HasValue)
                {
                    SpotPriceChangePercent = trp.SpotPriceChangePercent;
                }
                if (UnderlyingName == null)
                {
                    UnderlyingName = trp.UnderlyingName;
                }
                Pv += trp.Pv;
                PvContainsKnockOut += trp.PvContainsKnockOut;
                Delta += trp.Delta;
                if (!DeltaT1.HasValue)
                {
                    DeltaT1 = trp.DeltaT1;
                }
                else if (trp.DeltaT1.HasValue)
                {
                    DeltaT1 += trp.DeltaT1.Value;
                }
                SA_Delta += trp.SA_Delta;
                Gamma += trp.Gamma;
                Theta += trp.Theta;
                if (PS.Config.Company == CompanyEnum.红塔众鑫)
                {
                    ThetaNet += trp.ThetaNet;
                }

                Rho += trp.Rho;
                Vega += trp.Vega;
                DdeltaDt += trp.DdeltaDt;
                DdeltaDvol += trp.DdeltaDvol;
                DvegaDt += trp.DvegaDt;
                DvegaDvol += trp.DvegaDvol;
                DeltaCash += trp.DeltaCash;
                GammaCash += trp.GammaCash;
                DeltaInLots += trp.DeltaInLots;
                DeltaInLotsContainsKnockOut += trp.DeltaInLotsContainsKnockOut;
                GammaInLots += trp.GammaInLots;
                GammaInLotsContainsKnockOut += trp.GammaInLotsContainsKnockOut;
                Notional += trp.Notional;
                OriginalNotional += trp.OriginalNotional;
                OriginalNotionalV += trp.OriginalNotionalV;
                Lots += trp.Lots;
                LotsNewInfo += trp.LotsNewInfo;

                TradePrice += trp.TradePrice;
                OriginalPrincipalSum += trp.OriginalPrincipalSum;
                DailyPnl += trp.DailyPnl;
                ExercisePnl += trp.ExercisePnl;
                TotalPnl += trp.TotalPnl;
                AccruedTotalPnl += trp.AccruedTotalPnl;
                ClientName = trp.ClientName;
                ClientId = trp.ClientId;
                StockEqvNotional += trp.StockEqvNotional ?? 0;
                BookId = BookId != trp.BookId ? 0 : BookId;
            }

            if (OptionVolume.HasValue && OptionVolume.Value > 0)
            {
                DeltaPercent = Delta / OptionVolume.Value;
            }

            if (depth > 0)
            {
                return this;
            }

            if (viewList == null)
            {
                viewList = new List<TradingRiskParameter>();
            }

            //对冲交易特殊处理合计

            if (ConsTrade.TradeTypesForHedge.Contains(trp.TradeType))
            {
                TradingRiskParameter tempTrp = null;
                if (trp.TradeType == "场内期权")
                {
                    tempTrp = viewList.FirstOrDefault(t => t.TradeType == "场内期权" && t.ExchangeOptionCode == trp.ExchangeOptionCode);
                }
                else
                {
                    tempTrp = viewList.FirstOrDefault(t => ConsTrade.TradeTypesForHedge.Contains(t.TradeType) && t.UnderlyingCode == trp.UnderlyingCode && t.TradeType != "场内期权");
                }
                if ((trp.TradeType == "股票" || trp.TradeType == "商品期货" || trp.TradeType == "信用债") && string.IsNullOrWhiteSpace(trp.CallPut))
                {
                    trp.CallPut = trp.Notional >= 0 ? ConsGlobal.CallPut.Call : ConsGlobal.CallPut.Put;
                }
                if (tempTrp == null)
                {
                    tempTrp = new TradingRiskParameter()
                    {
                        IsOption = false,
                        TradeId = trp.TradeId,
                        Vol = trp.Vol,
                        TradeSavedVol = trp.TradeSavedVol
                    }.InnerAddItem(trp, depth + 1);

                    viewList.Add(tempTrp);
                }
                else
                {
                    tempTrp.InnerAddItem(trp, depth + 1);
                }

                HedgePv = (HedgePv ?? 0) + trp.Pv;
                HedgeDelta = (HedgeDelta ?? 0) + trp.Delta;
            }
            else
            {
                viewList.Add(trp);
            }

            return this;
        }

        public TradingRiskParameter Clone()
        {
            return (TradingRiskParameter)MemberwiseClone();
        }

        public override string ToString()
        {
            //tradeObj.AssetId, tradeObj.TradeType, longShort, tradeObj.UnderlyingCode, tradeObj.ExchangeOptionCode
            var tradeId = TradeId > 0 ? TradeId.ToString() : $"{BookId}_{TradeType}_{PositionType}";
            return $"{tradeId}--{TradeType}--{UnderlyingCode}";
        }

        /// <summary>
        /// gamma定制
        /// </summary>
        public double? GammaCustom { get; set; }


        /// <summary>
        /// Delta手数(包含敲出，敲出为0)
        /// </summary>
        public double DeltaInLotsContainsKnockOut { get; set; }


        /// <summary>
        /// 可对冲Gamma手数(包含敲出，敲出为0)
        /// </summary>
        public double GammaInLotsContainsKnockOut { get; set; }

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

        /// <summary>
        /// Pv (包含敲出，敲出为payoff)
        /// </summary>
        public double PvContainsKnockOut { get; set; }


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

        /// <summary>
        /// 红塔定制:Theta(轧差)
        /// </summary>
        public double ThetaNet { get; set; }
    }

    public class TradingRiskParameter_Company
    {

    }

    /// <summary>
    /// 广汽资本定制
    /// </summary>
    public class TradingRiskParameter_GuangQiZiBen : TradingRiskParameter_Company
    {
        //Delta暴露指所有品种Delta敞口名义金额绝对值相加；

        /// <summary>
        /// 调整Delta暴露=Delta*标的价格*波动率/sqrt(243)；
        /// </summary>
        public double DeltaAdjust { get; set; }

        /// <summary>
        /// 调整Gamma暴露=0.5*Gamma*（标的价格*波动率/sqrt(243) ）
        /// </summary>
        public double GammaAdjust { get; set; }
    }

    /// <summary>
    /// 天示定制
    /// </summary>
    public class TradingRiskParameter_TianShi : TradingRiskParameter_Company
    {
        /// <summary>
        /// 调仓手数=期货持仓-场外期权delta手数
        /// </summary>
        public double PositionAdjustLots { get; set; }

        /// <summary>
        /// 风险度=调仓手数/场外期权delta手数
        /// </summary>
        public double RiskDegree { get; set; }
    }

    public class TradingRiskParameterSortComparer : IComparer<TradingRiskParameter>
    {
        private int GetTypeSortValue(TradingRiskParameter x)
        {
            if (x.InstrumentType == "Stock" && !x.IsSynthetic)
            {
                return 1;
            }

            if (x.InstrumentType == "Stock" && x.IsSynthetic)
            {
                return 2;
            }

            if (x.InstrumentType == "CommodityFutures" && x.IsSynthetic)
            {
                return 3;
            }

            return 4;
        }

        public int Compare(TradingRiskParameter x, TradingRiskParameter y)
        {
            var xSortValue = GetTypeSortValue(x);
            var ySortValue = GetTypeSortValue(y);
            if (xSortValue != ySortValue)
            {
                return xSortValue - ySortValue;
            }

            return string.Compare(x.UnderlyingCode, y.UnderlyingCode, StringComparison.Ordinal);
        }

        public static readonly TradingRiskParameterSortComparer Default;

        static TradingRiskParameterSortComparer()
        {
            Default = new TradingRiskParameterSortComparer();
        }
    }
}