using System.ComponentModel.DataAnnotations.Schema;

namespace YLErp.DBModels
{
    [Table("trade_span")]
    public class trade_span : TradeExtendBase
    {
        public static string LogClass = "trade_span";
        private double? spv1;
        private double? spv2;
        private double? spv3;
        private double? spv4;
        private double? spv5;
        private double? spv6;
        private double? spv7;
        private double? spv8;
        private double? spv9;
        private double? spv10;
        private double? spv11;
        private double? spv12;
        private double? spv13;
        private double? spv14;
        private double? spv;
        private double? worstCastClientPayable;
        private double? twoSideMargin;
        private double? delta;
        private double? underlyingPrice;
        private double? deltaMargin;
        private double? initialMargin;
        private double? riskExposure;
        private double? margin;
        private double? cashDeposit;
        private double? positionWin;
        private double? im;
        private double? vm;
        private double? commission;
        private double? pfe;
        private double? spv15;
        private double? spv16;
        private double? spv17;
        private double? swapInitMargin;
        private double? swapWinLoss;

        /// <summary>
        /// 
        /// </summary>
        [DisplayName("ValueDate")]
        public DateTime ValueDate { get; set; }

        /// <summary>
        /// 涨停波动率不变
        /// <para>海通：价格涨 + 波动率变大</para>
        /// <para>宏源: 价格不变</para>
        /// </summary>
        [DisplayName("Spv1")]
        public double? Spv1
        {
            get => spv1;
            set => spv1 = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 涨停波动率变
        /// <para>海通：价格涨 + 波动率不变</para>
        /// <para>宏源: 价格涨</para>
        /// </summary>
        [DisplayName("Spv2")]
        public double? Spv2
        {
            get => spv2;
            set => spv2 = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 跌停波动率不变
        /// <para>海通：价格涨 + 波动率变小</para>
        /// <para>宏源: 价格跌</para>
        /// </summary>
        [DisplayName("Spv3")]
        public double? Spv3
        {
            get => spv3;
            set => spv3 = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 跌停波动率变
        /// 海通：价格不变 + 波动率变大
        /// </summary>
        [DisplayName("Spv4")]
        public double? Spv4
        {
            get => spv4;
            set => spv4 = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 海通：价格不变 + 波动率变小
        /// </summary>
        public double? Spv5
        {
            get => spv5;
            set => spv5 = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 海通：价格跌 + 波动率变大
        /// </summary>
        public double? Spv6
        {
            get => spv6;
            set => spv6 = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 海通：价格跌 + 波动率不变
        /// </summary>
        public double? Spv7
        {
            get => spv7;
            set => spv7 = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 海通：价格跌 + 波动率变小
        /// </summary>
        public double? Spv8
        {
            get => spv8;
            set => spv8 = NumberHelper.Normalize(value);
        }

        public double? Spv9
        {
            get => spv9;
            set => spv9 = NumberHelper.Normalize(value);
        }
        public double? Spv10
        {
            get => spv10;
            set => spv10 = NumberHelper.Normalize(value);
        }
        public double? Spv11
        {
            get => spv11;
            set => spv11 = NumberHelper.Normalize(value);
        }
        public double? Spv12
        {
            get => spv12;
            set => spv12 = NumberHelper.Normalize(value);
        }
        public double? Spv13
        {
            get => spv13;
            set => spv13 = NumberHelper.Normalize(value);
        }
        public double? Spv14
        {
            get => spv14;
            set => spv14 = NumberHelper.Normalize(value);
        }
        public double? Spv15
        {
            get => spv15;
            set => spv15 = NumberHelper.Normalize(value);
        }
        public double? Spv16
        {
            get => spv16;
            set => spv16 = NumberHelper.Normalize(value);
        }
        public double? Spv17
        {
            get => spv17;
            set => spv17 = NumberHelper.Normalize(value);
        }
        /// <summary>
        /// 当前持仓市值
        /// 瑞达span算法Spv1234..这些需要减去当前持仓市值，得到的Pnl1234..来做span算法处理
        /// </summary>
        public double? Spv
        {
            get => spv;
            set => spv = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 客户买入时为负数
        /// 客户卖出时为正数
        /// </summary>
        public double? WorstCastClientPayable
        {
            get => worstCastClientPayable;
            set => worstCastClientPayable = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 客户预付金最大亏损
        /// </summary>
        public double? MaxlossMargin { get; set; }

        /// <summary>
        /// 双向预付金
        /// </summary>
        public double? TwoSideMargin
        {
            get => twoSideMargin;
            set => twoSideMargin = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 交易员角度看的Delta
        /// </summary>
        public double? Delta
        {
            get => delta;
            set => delta = NumberHelper.Normalize(value);
        }

        public double? UnderlyingPrice
        {
            get => underlyingPrice;
            set => underlyingPrice = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 客户买入时为负数
        /// 客户卖出时针对瑞达可正可负
        /// </summary>
        public double? DeltaMargin
        {
            get => deltaMargin;
            set => deltaMargin = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 初始预付金 * 额外系数
        /// </summary>
        public double? InitialMargin
        {
            get => initialMargin;
            set => initialMargin = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 
        /// </summary>
        public void SetWorstCastClientPayable()
        {
            var worst = Spv1 ?? 0;

            if (Spv2.HasValue && worst < Spv2.Value)
            {
                worst = Spv2.Value;
            }

            if (Spv3.HasValue && worst < Spv3.Value)
            {
                worst = Spv3.Value;
            }

            if (Spv4.HasValue && worst < Spv4.Value)
            {
                worst = Spv4.Value;
            }

            if (Spv5.HasValue && worst < Spv5.Value)
            {
                worst = Spv5.Value;
            }

            if (Spv6.HasValue && worst < Spv6.Value)
            {
                worst = Spv6.Value;
            }

            if (Spv7.HasValue && worst < Spv7.Value)
            {
                worst = Spv7.Value;
            }

            if (Spv8.HasValue && worst < Spv8.Value)
            {
                worst = Spv8.Value;
            }

            if (Spv9.HasValue && worst < Spv9.Value)
            {
                worst = Spv9.Value;
            }

            if (Spv10.HasValue && worst < Spv10.Value)
            {
                worst = Spv10.Value;
            }

            if (Spv11.HasValue && worst < Spv11.Value)
            {
                worst = Spv11.Value;
            }

            if (Spv12.HasValue && worst < Spv12.Value)
            {
                worst = Spv12.Value;
            }

            if (Spv13.HasValue && worst < Spv13.Value)
            {
                worst = Spv13.Value;
            }

            if (Spv14.HasValue && worst < Spv14.Value)
            {
                worst = Spv14.Value;
            }
            if (Spv15.HasValue && worst < Spv15.Value)
            {
                worst = Spv15.Value;
            }
            if (Spv16.HasValue && worst < Spv16.Value)
            {
                worst = Spv16.Value;
            }
            if (Spv17.HasValue && worst < Spv17.Value)
            {
                worst = Spv17.Value;
            }
            WorstCastClientPayable = worst;
        }


        public int? VarietyId { get; set; }

        public int? UnderlyingId { get; set; }

        public string UnderlyingCode { get; set; }

        public string Comment { get; set; }

        public int? ClientId { get; set; }

        /// <summary>
        /// 风险敞口（假设公司当天行权，客户需要支付的payoff）
        /// </summary>
        public double? RiskExposure
        {
            get => riskExposure;
            set => riskExposure = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 追保金额
        /// </summary>
        public double? Margin
        {
            get => margin;
            set => margin = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 当前预付金
        /// </summary>
        public double? CashDeposit
        {
            get => cashDeposit;
            set => cashDeposit = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 交易员角度浮盈额，客户角度浮亏额，该值为正数
        /// </summary>
        public double? PositionWin
        {
            get => positionWin;
            set => positionWin = NumberHelper.Normalize(value);
        }

        public double? PositionWinLoss { get; set; }

        /// <summary>
        /// 是否单独算预付金
        /// 目前只有交易员方向卖出的雪球凤凰期权用到了该字段
        /// 保本雪球和指数类的凤凰雪球，不参与组合预付金算法
        /// </summary>
        public bool? IsSingleMargin { get; set; }

        /// <summary>
        /// 该交易预付金是否是通过span算出来的
        /// 目前国君通过该字段做预付金算法区别对待
        /// </summary>
        public bool? IsSpanMargin { get; set; }

        /// <summary>
        /// 中金: IM
        /// </summary>
        public double? IM
        {
            get => im;
            set => im = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 中金: VM
        /// 交易员方向
        /// </summary>
        public double? VM
        {
            get => vm;
            set => vm = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 中金: 未收取的开仓费
        /// </summary>
        public double? Commission
        {
            get => commission;
            set => commission = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 中金: PFE
        /// </summary>
        public double? PFE
        {
            get => pfe;
            set => pfe = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 互换初始预付金
        /// </summary>
        public double? SwapInitMargin
        {
            get => swapInitMargin;
            set => swapInitMargin = NumberHelper.Normalize(value);
        }

        /// <summary>
        /// 互换收益
        /// </summary>
        public double? SwapWinLoss
        {
            get => swapWinLoss;
            set => swapWinLoss = NumberHelper.Normalize(value);
        }

        [NotMapped]
        public double Notional { get; set; }

        [NotMapped]
        public double StockEqvNotional { get; set; }

        public string PVJsons { get; set; }
        [NotMapped]
        public List<PVJson> PVJsonList { get; set; } = new List<PVJson>();

        // 扩展字段，添加多个节点的内容
        public string Extensions { get; set; }

        public T GetFromExtensions<T>(string nodeName) where T : class
        {
            var ext = JsonHelper.Deserialize<Dictionary<string, object>>(Extensions);
            if (ext != null && ext.ContainsKey(nodeName))
            {
                return JsonHelper.Deserialize<T>(ext[nodeName]?.ToString());
            }
            else
            {
                return null;
            }
        }
        public void SetExtensions<T>(string nodeName, T obj)
        {
            var ext = JsonHelper.Deserialize<Dictionary<string, object>>(Extensions) ?? new Dictionary<string, object>();
            if (string.IsNullOrEmpty(nodeName))
            {
                nodeName = $"extensions_{nameof(T)}";
            }
            ext[nodeName] = JsonHelper.ToJson(obj);
            Extensions = JsonHelper.ToJson(ext);
        }


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

        /// <summary>
        /// 反向取值spv
        /// </summary>
        public trade_span ReverseSpv()
        {
            if (Spv1.HasValue)
            {
                Spv1 = -Spv1.Value;
            }

            if (Spv2.HasValue)
            {
                Spv2 = -Spv2.Value;
            }

            if (Spv3.HasValue)
            {
                Spv3 = -Spv3.Value;
            }

            if (Spv4.HasValue)
            {
                Spv4 = -Spv4.Value;
            }

            if (Spv5.HasValue)
            {
                Spv5 = -Spv5.Value;
            }

            if (Spv6.HasValue)
            {
                Spv6 = -Spv6.Value;
            }

            if (Spv7.HasValue)
            {
                Spv7 = -Spv7.Value;
            }

            if (Spv8.HasValue)
            {
                Spv8 = -Spv8.Value;
            }

            if (Spv9.HasValue)
            {
                Spv9 = -Spv9.Value;
            }

            if (Spv10.HasValue)
            {
                Spv10 = -Spv10.Value;
            }

            if (Spv11.HasValue)
            {
                Spv11 = -Spv11.Value;
            }

            if (Spv12.HasValue)
            {
                Spv12 = -Spv12.Value;
            }

            if (Spv13.HasValue)
            {
                Spv13 = -Spv13.Value;
            }

            if (Spv14.HasValue)
            {
                Spv14 = -Spv14.Value;
            }
            if (Spv15.HasValue)
            {
                Spv15 = -Spv15.Value;
            }
            if (Spv16.HasValue)
            {
                Spv16 = -Spv16.Value;
            }
            if (Spv17.HasValue)
            {
                Spv17 = -Spv17.Value;
            }
            return this;
        }

        /// <summary>
        /// 设置所有spv为相同值
        /// </summary>
        public trade_span SetAllSpvAndWorst(double sameValue)
        {
            Spv1 = Spv2 = Spv3 = Spv4 = Spv5 = Spv6 = Spv7 = Spv8 = Spv9 = Spv10 = Spv11 = Spv12 = Spv13 = Spv14 = Spv15 = Spv16 = Spv17 = worstCastClientPayable = deltaMargin = sameValue;

            return this;
        }
    }
}