using Newtonsoft.Json;
using System.ComponentModel.DataAnnotations.Schema;
using YLErp.Commons;
using YLErp.DBModels.Attributes;
using YLErp.DBModels.Enums;
using YLErp.DBModels.Helpers;
using YLErp.Enums;
using YLErp.Helpers;
using YLErp.Models;

namespace YLErp.DBModels
{
    /// <summary>
    /// 这个类做为Trade表基础类
    /// 不要添加NotMapped属性
    /// 可以添加属性转换方法
    /// </summary>
    public class OtcTradeBase : DBModelBase, IDBModelWithCreator
    {
        [DisplayName("结构类型")]
        [TradeAuditChangeMsg]
        [DataChange]
        public string TradeType
        {
            get => tradeType;
            set => tradeType = value ?? "";
        }

        /// <summary>
        /// 交易本身的对冲波动率
        /// </summary>
        [DisplayName("对冲波动率")]
        [DataChange]
        public double? TradeSavedVol { get; set; }

        /// <summary>
        /// 创建人ID
        /// </summary>
        [DisplayName("操作人")]
        public int? CreatorId { set; get; }

        /// <summary>
        /// 创建人名称
        /// </summary>
        [DisplayName("操作人")]
        public string CreatorName { set; get; }

        [DisplayName("创建时间")]
        [DataChange(true)]
        public DateTime? CreateDate { get; set; }

        /// <summary>
        /// 匹配的交易
        /// </summary>
        public string PairTrade
        {
            get => pairTrade;
            set => pairTrade = value ?? "";
        }

        //[DisplayName("修改记录")]
        //[TradeAuditExclude]
        //public string ChangeMsg
        //{
        //    get => changeMsg;
        //    set => changeMsg = value ?? "";
        //}

        /// <summary>
        /// 单份 期权价格
        /// </summary>
        [DisplayName("权利金"), TradeAuditChangeMsg]
        [DataChange]
        public double? TradeSinglePrice { get; set; }

        [DisplayName("组信息")]
        public int? GroupId { get; set; }

        [DisplayName("组名")]
        public string GroupName
        {
            get => groupName;
            set => groupName = value ?? "";
        }

        [DisplayName("平滑过渡天数"), TradeAuditChangeMsg]
        [DataChange]
        public int? NumOfSmoothingDays { get; set; }

        [DisplayName("结构化交易父ID")]
        public int ParentTradeId { get; set; }

        [DisplayName("目标波动率"), TradeAuditChangeMsg]
        [DataChange]
        public double? TradeCloseVolatility { get; set; }

        [DisplayName("成交波动率"), TradeAuditChangeMsg]
        [DataChange]
        public double? TradeOpenVolatility { get; set; }

        /// <summary>
        /// 平仓/执行 到期日期
        /// </summary>
        [DisplayName("平仓/执行日期")]
        public DateTime? UnWindDate { get; set; }

        [DisplayName("平仓份额")]
        public double? UnWindNotional { get; set; }

        /// <summary>
        /// 1代表开仓已复核
        /// 2代表平仓已复核
        /// 3代表行权已复核
        /// 0代表待复核
        /// </summary>
        [TradeAuditExclude]
        [DataChange(true)]
        public int? CheckStatus { get; set; }

        [TradeAuditExclude]
        [DataChange(true)]
        public int? CheckTradeUpdate { get; set; }

        private double? originalStockEqvNotional;
        private string tradeType;
        private string pairTrade;
        private string groupName;
        private string tradeUnit;

        /// <summary>
        /// 期权标的期初价格
        /// </summary>
        [NotMapped]
        public double? InitialSpotPrice
        {
            get => SpotPrice;
            set => SpotPrice = value;
        }

        [DisplayName("相对行权价"), TradeAuditChangeMsg]
        [DataChange]
        public string IsMoneynessOption { get; set; }

        /// <summary>
        /// 该字段显示的是交易的最新数量，和TradeOriginalAmount的差别在于部分平仓时，需要减掉已部分平仓部分数据
        /// </summary>
        [DisplayName("持仓数量"), TradeAuditChangeMsg]
        [DataChange]
        public double TradeAmount { get; set; }

        /// <summary>
        /// 关联varity表的冗余字段
        /// 这个字段没啥用处，需要删掉
        /// </summary>
        [DisplayName("交易单位")]
        [TradeAuditExclude]
        [DataChange(true)]
        public string TradeUnit
        {
            get => tradeUnit;
            set => tradeUnit = value ?? "";
        }

        /// <summary>
        /// 名义本金
        /// <para> 远期 掉期 基差价差 名义本金 取 最大</para>
        /// </summary>
        [DisplayName("名义本金"), TradeAuditChangeMsg]
        [DataChange]
        public double StockEqvNotional { get; set; }

        [DisplayName("最大名义本金(组合标的)")]
        [DataChange]
        /// <summary>
        /// 最大名义本金(组合标的)
        /// </summary>
        public double? StockEqvNotionalMax { get; set; }

        /// <summary>
        /// 有效名义本金
        /// </summary>
        [DisplayName("有效名义本金"), TradeAuditChangeMsg]
        [DataChange]
        public double StockEqvNotionalReal { get; set; }

        [DisplayName("波动率类型"), TradeAuditExclude]
        [DataChange(true)]
        public string VolType { get; set; }

        /// <summary>
        /// 标的资产类型 期货期权都是CommodityFutures，股票是Stock,远期是 期货期权都是CommodityFutures
        /// </summary>
        [DisplayName("标的资产类型")]
        [TradeAuditExclude]
        [DataChange(true)]
        public string UnderlyingInstrumentType { get; set; }

        /// <summary>
        /// 之前是行权日，后名字改为到期日
        /// </summary>
        [DisplayName("到期日期"), TradeAuditChangeMsg]
        [DataChange]
        public DateTime? ExerciseDate { get; set; }

        [DisplayName("交易员")]
        [TradeAuditChangeMsg]
        [DataChange]
        public string TraderName { get; set; }

        [DisplayName("交易员")]
        public int TraderId { get; set; }

        [DataChange]
        [DisplayName("波动率")]
        public double? Vol { get; set; }

        /// <summary>
        /// 目前东证专有  vol pv - midvol pv 数据库存在 TradeMeta
        /// </summary>
        [NotMapped]
        public double? Day1Pnl { get; set; }

        /// <summary>
        /// 目前东证专有  数据库存在 TradeMeta
        /// </summary>
        [NotMapped]
        public double? MidVol { get; set; }

        /// <summary>
        /// 汇率
        /// </summary>
        [NotMapped]
        public double? ExchangeRate { get; set; }

        [DisplayName("执行价格"), TradeAuditChangeMsg]
        [DataChange]
        public double? Strike { get; set; }

        [DisplayName("标的代码")]
        [DataChange(true)]
        public int UnderlyingId { get; set; }

        [DisplayName("基差挂钩标的代码")]
        [DataChange(true)]
        public int? BasisUnderlyingId { get; set; }

        [DisplayName("基差挂钩标的代码")]
        public string BasisUnderlyingCode { get; set; }

        [DisplayName("基差")]
        public double? BasisGap { get; set; }

        /// <summary>
        /// 场内期权代码才有，对应exchangelistoption表
        /// 3.9版本场内期权交易迁移到exchange_trade表
        /// </summary>
        [NotMapped]
        public string ExchangeOptionCode { get; set; }

        //也是不应该要的冗余字段
        [DisplayName("簿记账户")]
        [TradeAuditChangeMsg]
        public string AssetBookName { get; set; }

        [DisplayName("簿记账户")]
        public int AssetId { get; set; }

        /// <summary>
        /// 该字段显示的是交易的最新份额，和OriginalNotional的差别在于部分平仓时，需要减掉已部分平仓部分数据
        /// </summary>
        [DisplayName("持仓份额"), TradeAuditChangeMsg]
        [DataChange]
        public double Notional { get; set; }

        /// <summary>
        /// 看涨看跌
        /// </summary>
        [DisplayName("看涨看跌"), TradeAuditChangeMsg]
        [DataChange]
        public string OptionType { get; set; }

        [DisplayName("定价模型")]
        public string PricingModel { get; set; }

        /// <summary>
        /// 行权方式
        /// </summary>
        [DisplayName("行权方式")]
        [DataChange]
        public string ExerciseMode { get; set; }

        [DisplayName("无风险利率")]
        [DataChange]
        public double? NoRiskRate { get; set; }

        /// <summary>
        /// 商品期货期权标的期初价格
        /// </summary>
        [DisplayName("标的价格"), TradeAuditChangeMsg]
        [DataChange]
        public double? SpotPrice { get; set; }

        /// <summary>
        /// 交易编号
        /// </summary>
        [DisplayName("交易编号")]
        public string TradeNumber { get; set; }

        ///// <summary>
        ///// 合同编号
        ///// </summary>
        //[DisplayName("合同编号")]
        //public string ContractNo { get; set; }

        /// <summary>
        /// 客户信息
        /// </summary>
        [DisplayName("客户名称")]
        public int ClientId { get; set; }

        /// <summary>
        /// 客户名称
        /// </summary>
        [DisplayName("客户名称")]
        [TradeAuditChangeMsg]
        [DataChange]
        public string ClientName { get; set; }

        /// <summary>
        /// 标的代码
        /// </summary>
        [DisplayName("标的代码")]
        [TradeAuditChangeMsg]
        [DataChange]
        public string UnderlyingCode { get; set; }

        /// <summary>
        /// 标的类型,
        /// 没什么用，等待删除
        /// </summary>
        [DisplayName("标的类型")]
        [TradeAuditExclude]
        [DataChange(true)]
        public string UnderlyingAssetClass { get; set; }

        /// <summary>
        /// 成交日期
        /// </summary>
        [DisplayName("成交日期"), TradeAuditChangeMsg]
        [DataChange]
        public DateTime? TradeDate { get; set; }

        /// <summary>
        /// 买卖方向
        /// </summary>
        [DisplayName("买卖方向")]
        [TradeAuditChangeMsg]
        [DataChange]
        public string BuySell { get; set; }

        /// <summary>
        /// 开始日期 目前没什么用
        /// </summary>
        [DisplayName("开始日期")]
        public DateTime? StartDate { get; set; }

        /// <summary>
        /// 标的到期日(也没什么意义的一个字段吧,反而和ExerciseDate混淆，导致交易确认书等取错字段)
        /// </summary>
        [DisplayName("标的到期日"), TradeAuditExclude]
        [DataChange(true)]
        public DateTime? MaturityDate { get; set; }

        /// <summary>
        /// 仅用于自定义交易存储观察日列表的Json字符串
        /// </summary>
        [DisplayName("观察日")]
        public string ObservationDateStr { get; set; }

        private double? _tradePrice;
        /// <summary>
        /// 交易价格
        /// <para>远期：代表交易员资金方向，存储的数据和页面填写的一致，正代表交易员收，负代表交易员支付，不需要再考虑买卖方向</para>
        /// <para>期权：代表期权价值，如果需要判断是交易员收取还是支付，需要配合买卖方向处理</para>
        /// </summary>
        [DisplayName("成交总额"), TradeAuditChangeMsg]
        [DataChange]
        public double? TradePrice
        {
            set => _tradePrice = OtcFormatHelper.GetTradePriceDouble(value ?? 0);
            get => _tradePrice;
        }

        [NotMapped]
        public double? AccurateTradePrice { get; set; }

        /// <summary>
        /// 交易状态
        /// </summary>
        [DisplayName("交易状态")]
        public string TradeStatus { get; set; }

        [TradeAuditExclude]
        [DataChange(true)]
        public string ProcessStatus { get; set; }

        [TradeAuditExclude]
        [DataChange(true)]
        public int ProcessOrderId { get; set; }
        /// <summary>
        /// 审批流程分支
        /// </summary>
        [TradeAuditExclude]
        [DataChange(true)]
        public int ProcessOrderBranch { get; set; }

        [TradeAuditExclude]
        [DataChange(true)]
        public DateTime? ProcessOptDate { get; set; }

        /// <summary>
        /// 结算方式(0：收盘价，1：结算价，2：参考价)
        /// </summary>
        [DisplayName("收益结算")]
        public SettlementTypeEnum SettlementType { get; set; }

        /// <summary>
        /// 是否有效_validstate
        /// </summary>
        [DisplayName("是否有效")]
        public string ValidState { get; set; }

        [DisplayName("备注"), TradeAuditChangeMsg]
        public string Comments { get; set; }

        [TradeAuditExclude]
        [DataChange(true)]
        public int? SentMailCount { get; set; }

        /// <summary>
        /// 期货手数,期权期货一致
        /// </summary>
        [DisplayName("手数")]
        [TradeAuditExclude]
        [DataChange(true)]
        public double? Lots { get; set; }

        ///// <summary>
        ///// 结算收益(已经去掉了权利金，且以交易员方向看的)
        ///// </summary>
        //[DisplayName("结算收益")]
        //[TradeAuditExclude]
        //public double? NetSettlement { get; set; }

        [DisplayName("是否存在部分平仓")]
        [TradeAuditExclude]
        [DataChange(true)]
        public int? HasPartialUnWind { get; set; }

        [DisplayName("成交份额")]
        [TradeAuditExclude]
        [DataChange(true)]
        public double? OriginalNotional { get; set; }

        /// <summary>
        /// 交易来源
        /// </summary>
        [DisplayName("交易来源")]
        [TradeAuditExclude]
        [DataChange(true)]
        public string TradeSource { get; set; }

        /// <summary>
        /// 期初名义本金
        /// </summary>
        [DisplayName("期初名义本金")]
        [TradeAuditExclude]
        [DataChange(true)]
        public double? OriginalStockEqvNotional
        {
            get => originalStockEqvNotional;
            set => originalStockEqvNotional = Math.Abs(value ?? 0);
        }

        /// <summary>
        /// 支持多标的组合名义本金取最大值
        /// 必须增加这个字段了,(OriginalStockEqvNotional会用于计算但有些公司在多标的名义本金的处理上有差异)
        /// </summary>
        [TradeAuditExclude]
        [DataChange(true)]
        public double? OriginalStockEqvNotionalV2 => PS.Config.ErpElement.UseStockEqvNotionalMax && StockEqvNotionalMax > 0
                    ? StockEqvNotionalMax : originalStockEqvNotional;

        /// <summary>
        /// 是否通过期权费率设置权利金
        /// </summary>
        [DisplayName("成交方式")]
        public bool? IsUsePremiumRate { get; set; }

        /// <summary>
        /// 是否为总额成交方式,默认false
        /// </summary>
        [DisplayName("总额成交")]
        public bool IsTradePricePayType { get; set; }

        /// <summary>
        /// 是否为期权年化,默认false
        /// </summary>
        [DisplayName("期权年化")]
        [DataChange]
        public bool IsAnnualized { get; set; }

        [DisplayName("年化系数")]
        [DataChange]
        public double? AnnualizeFactor { get; set; }

        /// <summary>
        /// 分红率
        /// </summary>
        [DisplayName("分红率")]
        [DataChange]
        public double? DividendRate { get; set; }

        private double _participationRate = 1;
        /// <summary>
        /// 参与率
        /// </summary>
        [DisplayName("参与率")]
        [DataChange]
        public double? ParticipationRate
        {
            get => _participationRate;
            set
            {
                if (value == null || value == 0)
                {
                    _participationRate = 1;
                }
                else
                {
                    _participationRate = value.Value;
                }
            }
        }

        /// <summary>
        /// 保底收益率
        /// </summary>
        [DisplayName("单笔保底收益")]
        [DataChange]
        public double? PrincipalRate { get; set; }

        [DisplayName("保底收益总额")]
        [TradeAuditChangeMsg]
        [DataChange]
        public double? OriginalPrincipalSum { get; set; }

        [DisplayName("保底收益")]
        [DataChange]
        public double? PrincipalRateWrite { get; set; }

        [DisplayName("保底收益")]
        [DataChange]
        public double? SinglePrincipalWrite { get; set; }


        /// <summary>
        /// 结算日期 -- 互换交易历史数据 SettlementDate 为 null
        /// </summary>
        [DisplayName("结算日期")]
        public DateTime? SettlementDate { get; set; }

        /// <summary>
        /// 结算标识（0：正常结算，1：延期结算）
        /// </summary>
        [DisplayName("结算标识")]
        public int SettlementFlag { get; set; }

        [NotMapped]
        public string SettlementFlagStr
        {
            get
            {
                return SettlementFlag == 1 ? "是" : "否";
            }
        }

        /// <summary>
        /// 结算标识修改时间
        /// </summary>
        [DisplayName("结算标识修改时间")]
        public DateTime? SettlementFlagDate { get; set; }

        /// <summary>
        /// 结算标识修改人
        /// </summary>
        [DisplayName("结算标识修改人")]
        public int? SettlementFlagOptId { get; set; }
        [NotMapped]
        public string SettlementFlagOptName { get; set; }

        /// <summary>
        /// 计算标识(0:全部,1:IgnoreMargin(忽略预付金计算使用初始预付金))
        /// </summary>
        public int CalcFlag { get; set; }

        [DisplayName("是否单笔交易确认书")]
        public int? IsSingleContract { get; set; }

        [DisplayName("权利金应付日"), TradeAuditChangeMsg]
        [DataChange]
        public DateTime? PremiumPayDate { get; set; }

        //[DisplayName("交易指令"), TradeAuditChangeMsg]
        //[DataChange]
        //public string TradeInstruction { get; set; }

        [DisplayName("期权费率"), TradeAuditChangeMsg]
        [DataChange]
        public double? PremiumRate { get; set; }

        //删除UnderlyingAssetName

        [DisplayName("标的名称"), TradeAuditExclude]
        [DataChange(true)]
        public string UnderlyingAssetName { get; set; }

        [DisplayName("标的品种")]
        [NotMapped]
        public string UnderlyingVariety { get; set; }

        [DisplayName("协议版本号")]
        public string ContractVersion { get; set; }

        [DisplayName("标的到期价格")]
        public double? FinalPrice { get; set; }

        [DisplayName("对手方角色")]
        public string OpponentRole { get; set; }

        /// <summary>
        /// 存续天数(默认为0,和银行业务有关时用到)
        /// </summary>
        [DisplayName("存续天数")]
        public short? DurationDays { get; set; }

        private string _structureType;
        /// <summary>
        /// 期权结构类型
        /// </summary>
        [DisplayName("期权结构类型")]
        [DataChange]
        public string StructureType
        {
            get => _structureType;
            set => _structureType = string.IsNullOrWhiteSpace(value) ? null : value;
        }

        /// <summary>
        /// 初始预付金
        /// </summary>
        [DisplayName("初始预付金")]
        [DataChange]
        public double? InitialMargin { get; set; }

        /// <summary>
        /// 结构说明
        /// </summary>
        [DisplayName("结构说明")]
        [TradeAuditExclude]
        public string StructureIntroduction { get; set; }

        /// <summary>
        /// 预付金模板
        /// </summary>
        [DisplayName("预付金模板")]
        [TradeAuditExclude]
        public string MarginTemplateName { get; set; }

        /// <summary>
        /// 预付金算法
        /// </summary>
        [DisplayName("预付金算法")]
        [TradeAuditChangeMsg]
        public MarginTypeEnum MarginType { get; set; }

        /// <summary>
        /// 预付金率（固定及按浮动盈亏算时的初始预付金率）
        /// </summary>
        [DisplayName("预付金率")]
        [TradeAuditChangeMsg]
        public double MarginRate { get; set; }

        /// <summary>
        /// 持仓预付金率（固定预付金率算法的时候会用到）
        /// </summary>
        [DisplayName("持仓预付金率")]
        [TradeAuditChangeMsg]
        public double PositionMarginRate { get; set; }

        /// <summary>
        /// 计价货币
        /// </summary>
        [DisplayName("计价货币")]
        [TradeAuditChangeMsg]
        public string QuoteCurrency { get; set; }

        /// <summary>
        /// 结算货币
        /// </summary>
        [DisplayName("结算货币")]
        [TradeAuditChangeMsg]
        public string SettlementCurrency { get; set; }

        /// <summary>
        /// 是否为组合交易
        /// 0：非分组交易
        /// 1：分组交易父亲交易
        /// 2：分组交易子交易
        /// </summary>
        public int IsGroup { get; set; }

        /// <summary>
        /// 扩展字段，以json格式存储
        /// </summary>
        public string ExtendInfo { get; set; }

        /// <summary>
        /// 是否夜盘
        /// </summary>
        [DisplayName("是否夜盘")]
        public bool IsNight { get; set; }

        /// <summary>
        /// 自定义结构扩展字段缓存
        /// </summary>
        private string _extendInfoCache;
        private List<ExtendInfoModel> _propertys;
        /// <summary>
        /// 自定义结构扩展字段
        /// </summary>
        [NotMapped]
        public List<ExtendInfoModel> Propertys
        {
            get
            {
                if (string.IsNullOrWhiteSpace(ExtendInfo))
                {
                    _propertys = new List<ExtendInfoModel>();
                }
                else if (ExtendInfo != _extendInfoCache)
                {
                    try
                    {
                        _extendInfoCache = ExtendInfo;
                        _propertys = JsonConvert.DeserializeObject<List<ExtendInfoModel>>(ExtendInfo);
                    }
                    catch { _propertys = new List<ExtendInfoModel>(); }
                }
                return _propertys;
            }
        }

        /// <summary>
        /// 扩展字段看涨看跌属性
        /// </summary>
        [NotMapped]
        public string ExtendOptionTypeInfo { get; set; }

        /// <summary>
        /// 累计id
        /// </summary>
        [NotMapped]
        public string AccumulatorOptionId { get; set; }

        /// <summary>
        /// 操作人ID
        /// </summary>
        [DisplayName("操作人")]
        [TradeAuditExclude]
        public int OptId { get; set; }

        /// <summary>
        /// 操作人名称
        /// </summary>
        [DisplayName("操作人")]
        [TradeAuditExclude]
        public string OptName { get; set; }

        /// <summary>
        /// 操作时间
        /// </summary>
        [DisplayName("操作时间")]
        [TradeAuditExclude]
        [DataChange(true)]
        public DateTime? OptDate { get; set; }

        /// <summary>
        /// 是否走审批 分组了结时用
        /// </summary>
        [DisplayName("是否走审批")]
        [TradeAuditExclude]
        [DataChange(true)]
        public bool IsApproval { get; set; }

        /// <summary>
        /// 是否自动簿记
        /// </summary>
        [DisplayName("是否走审批")]
        public bool? IsAutoGenerate { get; set; }
        /// <summary>
        /// 衡泰交易状态
        /// </summary>
        public int? HTStatus { get; set; }
        /// <summary>
        /// 用来标记该交易在修改时是否应提示操作人员注意
        /// </summary>
        [NotMapped]
        public bool Warning => DividendDate >= TradeDate;

        public DateTime DividendDate { get; set; } = new DateTime(2000, 1, 1);

        /// <summary>
        /// 成交份额和数量的乘积因子(份额=数量*CountRatio)
        /// 这个字段赋值主要用于交易列表中成交(持仓)数量的计算
        /// </summary>
        public int? CountRatio { get; set; }

        [NotMapped]
        public string CallPut => TradeHelper.GetCallPut(OptionType);

        /// <summary>
        /// 是否是期初价格状态 ： 是
        /// </summary>
        [NotMapped]
        public bool IsMoneynessOptionData => (IsOption() || TradeType == "结构化交易" || TradeType == "远期" || TradeType == "自定义交易") && IsMoneynessOption == "是";

        public override string ToString()
        {
            return $"{id},{UnderlyingCode},{TradeType}";
        }

        /// <summary>
        /// 是否期权
        /// </summary>
        public bool IsOption()
        {
            var tradeTypeName = TradeType ?? "";
            return tradeTypeName.IndexOf("期权") >= 0 || tradeTypeName.EndsWith("结构");
        }

        public string GetSettlementTypeDesc()
        {
            return EnumHelper.GetDescriptionByName(SettlementType);
        }

        public string GetExerciseModeCn()
        {
            return TradeHelper.GetExerciseModeCn(ExerciseMode);
        }

        public string GetStrikeString()
        {
            return (IsMoneynessOptionData ? (SpotPrice ?? 0) * (Strike ?? 0) : (Strike ?? 0)).OtcFormatUmPrice();
        }

        public string GetTradeSinglePriceString()
        {
            if (IsUsePremiumRate == true)
            {
                return (PremiumRate ?? 0).OtcFormat(OtcFormatFlag.premiumRateP);
            }
            else
            {
                return (TradeSinglePrice ?? 0).OtcFormat(OtcFormatFlag.tradeSinglePrice);
            }
        }

        Dictionary<string, string> _metaDic;

        /// <summary>
        /// 扩展元数据字典(特别增加这个字段为了这个类的扩展性)
        /// 以后不要轻易动这个字段了,前端和模板经常用到
        /// </summary>
        [NotMapped]
        public Dictionary<string, string> MetaDic
        {
            get => _metaDic ??= new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            set => _metaDic = value;
        }

        private string _tradeExtendJson;
        /// <summary>
        /// 奇异信息
        /// <para>使用时应调用GetExtendObj方法</para>
        /// </summary>
        [NotMapped]
        public string TradeExtendJson
        {
            get { return _tradeExtendJson; }
            set
            {
                if (_tradeExtendJson != value)
                {
                    _tradeExtendJson = value;
                    _extendInfo = null;
                }
            }
        }

        private TradeExtendBase _extendInfo = null;
        public T GetExtendObj<T>() where T : TradeExtendBase, new()
        {
            if (_extendInfo == null && string.IsNullOrWhiteSpace(this.TradeExtendJson))
            {
                _extendInfo = JsonHelper.ToObject<T>(this.TradeExtendJson);
            }

            return (T)_extendInfo;
        }

        /// <summary>
        /// 交易类型综合描述(也是个必须的基础属性)
        /// </summary>
        [NotMapped]
        public string TradeMultipleType
        {
            get
            {
                if (TradeType == "自定义交易")
                {
                    return (string.IsNullOrEmpty(StructureType) ? TradeType : StructureType) + (OptionType ?? "");
                }

                if (string.IsNullOrEmpty(TradeType) || TradeType == "自定义交易" || TradeType == "雪球期权" || TradeType == "凤凰期权")
                {
                    return TradeType;
                }

                if (TradeType == "收益互换")
                {
                    return TradeType + (OptionType ?? "");
                }

                if (TradeType == "远期" && !string.IsNullOrWhiteSpace(OptionType))
                {
                    return (string.IsNullOrEmpty(StructureType) ? TradeType : StructureType) + (OptionType == "看涨" ? "多头" : "空头");
                }

                if (TradeType == "结构化交易" || TradeType == "组合交易")
                {
                    return StructureType;
                }

                if (PS.Config.Is瑞达 && TradeType == "香草期权")
                {
                    return TradeHelper.GetExerciseModeCn(ExerciseMode) + OptionType;
                }

                return TradeHelper.GetExerciseModeCn(ExerciseMode) + TradeType.Replace("期权", string.Empty) + OptionType;
            }

        }

        public bool HasUnderlying()
        {
            return TradeType != "现金流交易";
        }

        /// <summary>
        /// 设置交易的完全了结状态(更新交易了结日期,交易状态，持仓份额，持仓名义本金)，一般在savecash之后调用
        /// </summary>
        /// <param name="unwindDate">了结日期</param>
        /// <param name="closedStatus">了结状态</param>
        public void SetFullClosedStatus(DateTime unwindDate, string closedStatus)
        {
            UnWindDate = unwindDate;
            TradeStatus = closedStatus;
            Notional = 0;
            TradeAmount = 0;
            StockEqvNotional = 0;
        }

        /// <summary>
        /// 持仓保底收益总额
        /// </summary>
        public double PrincipalSum() => OriginalStockEqvNotional == 0 ? 0 : (OriginalPrincipalSum * StockEqvNotional / OriginalStockEqvNotional) ?? 0;


        /// <summary>
        /// 采集价格字符串
        /// </summary>
        [NotMapped]
        public string Fixing { get; set; }
    }

    /// <summary>
    /// 用作trade表模型的基类
    /// </summary>
    public abstract class OtcTrade : OtcTradeBase
    {
        [NotMapped]
        public TradeSaveExt SaveExt { get; set; }

        public abstract IEnumerable<OtcTrade> GetSubTrades();

        public abstract T Get<T>() where T : TradeExtendBase;

        public abstract void Set<T>(T data) where T : TradeExtendBase;
    }

    /// <summary>
    /// 成交数量方式枚举
    /// </summary>
    public enum TradingNotionalFlag
    {
        None = 0,

        /// <summary>
        /// 实际名义本金
        /// </summary>
        StockEqvNotionalReal,

        /// <summary>
        /// 名义本金
        /// </summary>
        StockEqvNotional,

        /// <summary>
        /// 交易份额
        /// </summary>
        Notional,

        /// <summary>
        /// 交易数量
        /// </summary>
        TradeAmount
    }

    /// <summary>
    /// 成交权利金枚举
    /// </summary>
    public enum TradingPremiumFlag
    {
        None = 0,

        /// <summary>
        /// 权利金总额
        /// </summary>
        TradePrice,

        /// <summary>
        /// 权利金单价
        /// </summary>
        TradeSinglePrice,

        /// <summary>
        /// 权利金费率
        /// </summary>
        PremiumRate,

        /// <summary>
        /// 全部是0
        /// </summary>
        AllZero
    }

    /// <summary>
    /// 保存时用的扩展数据
    /// </summary>
    public class TradeSaveExt
    {
        /// <summary>
        /// 数量处理方式枚举
        /// </summary>
        public TradingNotionalFlag NotionalFlag { get; set; }

        /// <summary>
        /// 期权费处理方式枚举
        /// </summary>
        public TradingPremiumFlag PremiumFlag { get; set; }

        /// <summary>
        /// 最大标的价格(适用于组合标的)
        /// </summary>
        public double? MaxSpotPrice { get; set; }
    }

    /// <summary>
    /// 
    /// </summary>
    public class OtcTradeDto : OtcTradeBase
    {
        /// <summary>
        /// 最新标的价格
        /// </summary>
        public double? UnderlyingPrice { get; set; }

        /// <summary>
        /// 成交溢价
        /// </summary>
        public double? TradePremium { get; set; } = 0;

        /// <summary>
        /// 销售提成
        /// </summary>
        public TradeSalesCommissionInfo SalesCommission { get; set; }
    }

    /// <summary>
    /// 交易扩展基类
    /// </summary>
    public class TradeExtendBase : DBModelWithOperator
    {
        [TradeAuditExclude]
        [DataChange(true)]
        public override int id { get; set; }

        /// <summary>
        /// 交易信息
        /// </summary>
        [DisplayName("交易信息")]
        [TradeAuditExclude]
        [DataChange(true)]
        public virtual int TradeId { get; set; }
    }

    public class ExtendInfoModel
    {
        /// <summary>
        /// 更新时间
        /// <para>用于标记Dto是否需要更新</para>
        /// </summary>
        [JsonIgnore]
        public DateTime changeTime = DateTime.MinValue;
        private string _name;
        /// <summary>
        /// 字段名
        /// </summary>
        public string name
        {
            get => _name;
            set
            {
                _name = value;
                changeTime = DateTime.Now;
            }
        }
        private string _value;
        /// <summary>
        /// 字段值
        /// </summary>
        public string value
        {
            get => _value;
            set
            {
                _value = value;
                changeTime = DateTime.Now;
            }
        }
    }

    public class ExtendInfoDto : ExtendInfoModel
    {
        /// <summary>
        /// 字段配置信息
        /// </summary>
        public Structure_Details CustomInfo { get; private set; }

        /// <summary>
        /// 设置字段配置信息
        /// </summary>
        /// <param name="detailInfo"></param>
        public void SetCustomInfo(Structure_Details detailInfo)
        {
            if (detailInfo?.ColumnType == StructureColumnTypeEnum.COMBO_BOX_SINGLE)
            {
                var options = detailInfo.ColumnOptions.Split(',');
                if (!options.Contains(value))
                {
                    detailInfo = null;
                }
            }
            CustomInfo =
                detailInfo
                ?? new Structure_Details()
                {
                    ColumnType = StructureColumnTypeEnum.TEXT,
                    ColumnName = name,
                    ColumnDefaultValue = value
                };
        }

        public ExtendInfoDto(ExtendInfoModel obj)
        {
            name = obj.name;
            value = obj.value;
        }
    }
}