* Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies

*

* Please see distribution for license.

*/

* Creates reference portfolios from which View calculation status report can be generated.

*/

  /**

   * Reference portfolio name.

   */

  public static final String PORTFOLIO_NAME = "BBG_VS_REF_PRT";

  private static final int NUM_SECURITIES = 1;

  private final ExternalScheme _security = ExternalScheme.of("RefSec");

  private final PortfolioMaster _portfolios;

  private final PositionMaster _positions;

  private final SecurityMaster _securities;

  private int _identifiers;

  private Random _generation;

  public BloombergReferencePortfolioMaker(final PortfolioMaster portfolios, final PositionMaster positions, final SecurityMaster securities) {

    _portfolios = portfolios;

    _positions = positions;

    _securities = securities;

  }

  private ExternalIdBundle getBundle(final ManageableSecurity security) {

    final ExternalIdBundle bundle = security.getExternalIdBundle();

    final ExternalId identifier = bundle.getExternalId(_security);

    if (identifier != null) {

      return identifier.toBundle();

    } else {

      return bundle;

    }

  }

  private ManageableTrade createTrade(final ManageableSecurity security) {

    final ManageableTrade trade = new ManageableTrade(BigDecimal.ONE, getBundle(security), LocalDate.now(), OffsetTime.now(), ExternalId.of(

        "counterparty", "Foo"));

    if (BondFutureOptionSecurity.SECURITY_TYPE.equals(security.getSecurityType())) {

      trade.setPremium(-100d);

    } else if (IRFutureOptionSecurity.SECURITY_TYPE.equals(security.getSecurityType())) {

      trade.setPremium(100d);

    }

    return trade;

  }

  private ManageablePosition createPosition(final ManageableSecurity security) {

    final ManageablePosition position = new ManageablePosition(BigDecimal.ONE, getBundle(security));

    position.addTrade(createTrade(security));

    return position;

  }

 

  private ManageablePortfolioNode createNode(final String nodeName, final Collection<? extends ManageableSecurity> securities) {

    final ManageablePortfolioNode node = new ManageablePortfolioNode(nodeName);

    for (ManageableSecurity security : securities) {

      final ManageablePosition position = createPosition(security);

      node.addPosition(_positions.add(new PositionDocument(position)).getObjectId());

    }

    return node;

  }

 

  private void createPortfolio(final String portfolioName, final Iterable<ManageablePortfolioNode> nodes) {

    final ManageablePortfolioNode rootNode = new ManageablePortfolioNode("ROOT");

    final ManageablePortfolio portfolio = new ManageablePortfolio(portfolioName, rootNode);

    for (ManageablePortfolioNode node : nodes) {

      rootNode.addChildNode(node);

    }

    _portfolios.add(new PortfolioDocument(portfolio));

  }

  private void store(final ManageableSecurity security) {

    security.addExternalId(ExternalId.of(_security, Integer.toString(_identifiers++)));

    if (security.getExternalIdBundle().getValue(ExternalSchemes.BLOOMBERG_TICKER) == null) {

      security.addExternalId(ExternalId.of(ExternalSchemes.BLOOMBERG_TICKER, security.getSecurityType()));

    }

    _securities.add(new SecurityDocument(security));

  }

  private void resetGenerationState(final int i) {

    _generation = new Random(i);

  }

  private int select(final int n) {

    return _generation.nextInt(n);

  }

  private <T> T select(final T... data) {

    return data[_generation.nextInt(data.length)];

  }

  private BarrierDirection barrierDirection() {

    return select(BarrierDirection.values());

  }

  private BarrierType barrierType() {

    return select(BarrierType.values());

  }

  private BondFutureDeliverable bondFutureDeliverable() {

    final ExternalIdBundle identifiers;

    switch (select(2)) {

      case 0:

        identifiers = createCorporateBondSecurity().getExternalIdBundle();

        break;

      case 1:

        identifiers = createGovernmentBondSecurity().getExternalIdBundle();

        break;

      // Note: MunicipalBondSecurity is not implemented

      default:

        throw new IllegalStateException();

    }

    return new BondFutureDeliverable(identifiers, 1.0);

  }

  private String issuerDomicile() {

    return select("GB", "US");

  }

  private boolean bool() {

    return select(2) == 0;

  }

  private BusinessDayConvention businessDayConvention() {

    return select(BusinessDayConventionFactory.INSTANCE.getBusinessDayConvention("Following"), BusinessDayConventionFactory.INSTANCE.getBusinessDayConvention("Modified"),

        BusinessDayConventionFactory.INSTANCE.getBusinessDayConvention("None"));

  }

  private Currency currency() {

    return select(Currency.USD, Currency.GBP, Currency.EUR, Currency.JPY, Currency.CHF);

  }

  private Currency differentCurrency(final Currency to) {

    Currency c;

    do {

      c = currency();

    } while (to.equals(c));

    return c;

  }

  private DayCount dayCount() {

    return select(DayCountFactory.INSTANCE.getDayCount("Act/Act"), DayCountFactory.INSTANCE.getDayCount("30/360"));

  }

  @SuppressWarnings("unchecked")

  private ExerciseType exerciseType() {

    try {

      return select(AmericanExerciseType.class, EuropeanExerciseType.class, AsianExerciseType.class, BermudanExerciseType.class).newInstance();

    } catch (final Exception e) {

      throw new OpenGammaRuntimeException("Caught", e);

    }

  }

  private String exchange() {

    return select("XLON", "XNYS");

  }

  private Expiry expiry() {

    return new Expiry(ZonedDateTime.now().plusMonths(14));

  }

  private FixedInterestRateLeg fixedInterestRateLeg(final Notional notional) {

    final DayCount dayCount = dayCount();

    final Frequency frequency = frequency();

    final ExternalId regionIdentifier = region();

    final BusinessDayConvention businessDayConvention = businessDayConvention();

    final boolean eom = bool();

    final double rate = 0;

    return new FixedInterestRateLeg(dayCount, frequency, regionIdentifier, businessDayConvention, notional, eom, rate);

  }

  private FloatingInterestRateLeg floatingInterestRateLeg(final Notional notional) {

    final DayCount dayCount = dayCount();

    final Frequency frequency = frequency();

    final ExternalId regionIdentifier = region();

    final BusinessDayConvention businessDayConvention = businessDayConvention();

    final boolean eom = bool();

    final ExternalId floatingReferenceRateId = ExternalId.of(ExternalSchemes.BLOOMBERG_TICKER, "US0003M Index");

    final FloatingRateType floatingRateType = floatingRateType();

    return new FloatingInterestRateLeg(dayCount, frequency, regionIdentifier, businessDayConvention, notional, eom, floatingReferenceRateId, floatingRateType);

  }

  private FloatingRateType floatingRateType() {

    return select(FloatingRateType.values());

  }

  private Frequency frequency() {

    return select(SimpleFrequency.QUARTERLY, SimpleFrequency.ANNUAL, SimpleFrequency.MONTHLY);

  }

  private InterestRateNotional interestRateNotional() {

    final Currency currency = currency();

    final double amount = 5e6;

    return new InterestRateNotional(currency, amount);

  }

  private MonitoringType monitoringType() {

    return select(MonitoringType.values());

  }

  private OptionType optionType() {

    return select(OptionType.values());

  }

  private ExternalId region() {

    return ExternalId.of(ExternalSchemes.ISO_COUNTRY_ALPHA2, select("GB", "US"));

  }

  private SamplingFrequency samplingFrequency() {

    return select(SamplingFrequency.values());

  }

  private StubType stubType() {

    return select(StubType.values());

  }

  private YieldConvention yieldConvention() {

    return select(SimpleYieldConvention.MONEY_MARKET, SimpleYieldConvention.TRUE, SimpleYieldConvention.US_STREET);

  }

  private BondFutureOptionSecurity createBondFutureOptionSecurity() {

    final String tradingExchange = exchange();

    final String settlementExchange = exchange();

    final Expiry expiry = expiry();

    final ExerciseType exerciseType = exerciseType();

    final ExternalId underlyingIdentifier = createBondFutureSecurity().getExternalIdBundle().getExternalId(_security);

    final double pointValue = 1000;

    final Currency currency = currency();

    final double strike = 1.25;

    final OptionType optionType = optionType();

    final BondFutureOptionSecurity security = new BondFutureOptionSecurity(tradingExchange, settlementExchange, expiry, exerciseType, underlyingIdentifier, pointValue, currency, strike, optionType);

    store(security);

    return security;

  }

  public ManageablePortfolioNode createBondFutureOptionNode() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createBondFutureOptionSecurity());

    }

    return createNode(BondFutureOptionSecurity.SECURITY_TYPE, securities);

  }

  private CorporateBondSecurity createCorporateBondSecurity() {

    final String issuerName = "issuerName";

    final String issuerType = "issuerType";

    final String issuerDomicile = issuerDomicile();

    final String market = "market";

    final Currency currency = currency();

    final YieldConvention yieldConvention = yieldConvention();

    final Expiry lastTradeDate = expiry();

    final String couponType = "couponType";

    final double couponRate = 1.5;

    final Frequency couponFrequency = frequency();

    final DayCount dayCountConvention = dayCount();

    final ZonedDateTime interestAccrualDate = ZonedDateTime.now().minusMonths(24);

    final ZonedDateTime settlementDate = ZonedDateTime.now().minusMonths(12);

    final ZonedDateTime firstCouponDate = interestAccrualDate;

    final Double issuancePrice = 100d;

    final double totalAmountIssued = 1e9;

    final double minimumAmount = 50000;

    final double minimumIncrement = 50000;

    final double parAmount = 50000;

    final double redemptionValue = 100d;

    final CorporateBondSecurity security = new CorporateBondSecurity(issuerName, issuerType, issuerDomicile, market, currency, yieldConvention, lastTradeDate, couponType, couponRate,

          couponFrequency, dayCountConvention, interestAccrualDate, settlementDate, firstCouponDate, issuancePrice, totalAmountIssued, minimumAmount, minimumIncrement, parAmount, redemptionValue);

    store(security);

    return security;

  }

  public ManageablePortfolioNode createCorporateBondNode() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createCorporateBondSecurity());

    }

    return createNode(CorporateBondSecurity.SECURITY_TYPE, securities);

  }

  private GovernmentBondSecurity createGovernmentBondSecurity() {

    final String issuerName = "issuerName";

    final String issuerType = "issuerType";

    final String issuerDomicile = issuerDomicile();

    final String market = "market";

    final Currency currency = currency();

    final YieldConvention yieldConvention = yieldConvention();

    final Expiry lastTradeDate = expiry();

    final String couponType = "couponType";

    final double couponRate = 1.5;

    final Frequency couponFrequency = frequency();

    final DayCount dayCountConvention = dayCount();

    final ZonedDateTime interestAccrualDate = ZonedDateTime.now().minusMonths(24);

    final ZonedDateTime settlementDate = ZonedDateTime.now().minusMonths(12);

    final ZonedDateTime firstCouponDate = interestAccrualDate;

    final Double issuancePrice = 100d;

    final double totalAmountIssued = 1e9;

    final double minimumAmount = 50000;

    final double minimumIncrement = 50000;

    final double parAmount = 50000;

    final double redemptionValue = 100;

    final GovernmentBondSecurity security = new GovernmentBondSecurity(issuerName, issuerType, issuerDomicile, market, currency, yieldConvention, lastTradeDate, couponType, couponRate,

          couponFrequency, dayCountConvention, interestAccrualDate, settlementDate, firstCouponDate, issuancePrice, totalAmountIssued, minimumAmount, minimumIncrement, parAmount, redemptionValue);

    store(security);

    return security;

  }

  public ManageablePortfolioNode createGovernmentBondNode() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createGovernmentBondSecurity());

    }

    return createNode(GovernmentBondSecurity.SECURITY_TYPE, securities);

  }

  private MunicipalBondSecurity createMunicipalBondSecurity() {

    final String issuerName = "issuerName";

    final String issuerType = "issuerType";

    final String issuerDomicile = issuerDomicile();

    final String market = "market";

    final Currency currency = currency();

    final YieldConvention yieldConvention = yieldConvention();

    final Expiry lastTradeDate = expiry();

    final String couponType = "couponType";

    final double couponRate = 1.5;

    final Frequency couponFrequency = frequency();

    final DayCount dayCountConvention = dayCount();

    final ZonedDateTime interestAccrualDate = ZonedDateTime.now().minusMonths(24);

    final ZonedDateTime settlementDate = ZonedDateTime.now().minusMonths(12);

    final ZonedDateTime firstCouponDate = interestAccrualDate;

    final Double issuancePrice = 100d;

    final double totalAmountIssued = 1e9;

    final double minimumAmount = 50000;

    final double minimumIncrement = 50000;

    final double parAmount = 50000;

    final double redemptionValue = 100d;

    final MunicipalBondSecurity security = new MunicipalBondSecurity(issuerName, issuerType, issuerDomicile, market, currency, yieldConvention, lastTradeDate, couponType, couponRate,

          couponFrequency, dayCountConvention, interestAccrualDate, settlementDate, firstCouponDate, issuancePrice, totalAmountIssued, minimumAmount, minimumIncrement, parAmount, redemptionValue);

    store(security);

    return security;

  }

  public ManageablePortfolioNode createMunicipalBondNode() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createMunicipalBondSecurity());

    }

    return createNode(MunicipalBondSecurity.SECURITY_TYPE, securities);

  }

  public void createBondPortfolioNodes(final List<ManageablePortfolioNode> nodes) {

    nodes.add(createCorporateBondNode());

    nodes.add(createGovernmentBondNode());

    nodes.add(createMunicipalBondNode());

  }

  private CapFloorSecurity createCapFloorSecurity() {

    final ZonedDateTime startDate = ZonedDateTime.now().minusMonths(24);

    final ZonedDateTime maturityDate = ZonedDateTime.now().plusMonths(60);

    final double notional = 1e6;

    final ExternalId underlyingIdentifier = ExternalId.of(ExternalSchemes.RIC, "USDSFIX10Y=");

    final double strike = 0.01;

    final Frequency frequency = frequency();

    final Currency currency = currency();

    final DayCount dayCount = dayCount();

    final boolean payer = bool();

    final boolean cap = bool();

    final boolean ibor = bool();

    final CapFloorSecurity security = new CapFloorSecurity(startDate, maturityDate, notional, underlyingIdentifier, strike, frequency, currency, dayCount, payer, cap, ibor);

    store(security);

    return security;

  }

  public ManageablePortfolioNode createCapFloorNode() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createCapFloorSecurity());

    }

    return createNode(CapFloorSecurity.SECURITY_TYPE, securities);

  }

  private CapFloorCMSSpreadSecurity createCapFloorCMSSpreadSecurity() {

    final ZonedDateTime startDate = ZonedDateTime.now().minusMonths(24);

    final ZonedDateTime maturityDate = ZonedDateTime.now().plusMonths(60);

    final double notional = 1e6;

    final Currency currency = currency();

    final ExternalId longIdentifier = ExternalId.of(ExternalSchemes.RIC, "USDSFIX10Y=");

    final ExternalId shortIdentifier = ExternalId.of(ExternalSchemes.RIC, "USDSFIX1Y=");

    final double strike = 0;

    final Frequency frequency = frequency();

    final DayCount dayCount = dayCount();

    final boolean payer = bool();

    final boolean cap = bool();

    final CapFloorCMSSpreadSecurity security = new CapFloorCMSSpreadSecurity(startDate, maturityDate, notional, longIdentifier, shortIdentifier, strike, frequency, currency, dayCount, payer, cap);

    store(security);

    return security;

  }

  public ManageablePortfolioNode createCapFloorCMSSpreadNode() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createCapFloorCMSSpreadSecurity());

    }

    return createNode(CapFloorCMSSpreadSecurity.SECURITY_TYPE, securities);

  }

  private CashSecurity createCashSecurity() {

    final Currency currency = currency();

    final ExternalId region = region();

    final ZonedDateTime start = ZonedDateTime.now().minusMonths(6);

    final ZonedDateTime maturity = ZonedDateTime.now().plusMonths(6);

    final DayCount dayCount = dayCount();

    final double rate = 0.01;

    final double amount = 100000;

    final CashSecurity security = new CashSecurity(currency, region, start, maturity, dayCount, rate, amount);

    store(security);

    return security;

  }

  public ManageablePortfolioNode createCashNode() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createCashSecurity());

    }

    return createNode(CashSecurity.SECURITY_TYPE, securities);

  }

  private AgricultureForwardSecurity createAgricultureForwardSecurity() {

    final String unitName = "unitName";

    final Double unitNumber = null;

    final Expiry expiry = expiry();

    final Currency currency = currency();

    final double unitAmount = 0;

    final String category = "category";

    final AgricultureForwardSecurity security = new AgricultureForwardSecurity(unitName, unitNumber, expiry, currency, unitAmount, category);

    store(security);

    return security;

  }

  public ManageablePortfolioNode loadAgricultureForwardPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createAgricultureForwardSecurity());

    }

    return createNode(AgricultureForwardSecurity.SECURITY_TYPE, securities);

  }

  private EnergyForwardSecurity createEnergyForwardSecurity() {

    final String unitName = "unitName";

    final Double unitNumber = null;

    final Expiry expiry = expiry();

    final Currency currency = currency();

    final double unitAmount = 0;

    final String category = "category";

    final EnergyForwardSecurity security = new EnergyForwardSecurity(unitName, unitNumber, expiry, currency, unitAmount, category);

    store(security);

    return security;

  }

  public ManageablePortfolioNode loadEnergyForwardPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createEnergyForwardSecurity());

    }

    return createNode(EnergyForwardSecurity.SECURITY_TYPE, securities);

  }

  private MetalForwardSecurity createMetalForwardSecurity() {

    final String unitName = "unitName";

    final Double unitNumber = null;

    final Expiry expiry = expiry();

    final Currency currency = currency();

    final double unitAmount = 0;

    final String category = "category";

    final MetalForwardSecurity security = new MetalForwardSecurity(unitName, unitNumber, expiry, currency, unitAmount, category);

    store(security);

    return security;

  }

  public ManageablePortfolioNode loadMetalForwardPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createMetalForwardSecurity());

    }

    return createNode(MetalForwardSecurity.SECURITY_TYPE, securities);

  }

  public void loadCommodityForwardPortfolio() {

    loadAgricultureForwardPortfolio();

    loadEnergyForwardPortfolio();

    loadMetalForwardPortfolio();

  }

  private CommodityFutureOptionSecurity createCommodityFutureOptionSecurity() {

    final String tradingExchange = exchange();

    final String settlementExchange = exchange();

    final Expiry expiry = expiry();

    final ExerciseType exerciseType = exerciseType();

    final ExternalId underlyingIdentifier = ExternalId.of(ExternalSchemes.BLOOMBERG_TICKER, "US0003M Index");

    final double pointValue = 0;

    final Currency currency = currency();

    final double strike = 0;

    final OptionType optionType = optionType();

    final CommodityFutureOptionSecurity security = new CommodityFutureOptionSecurity(tradingExchange, settlementExchange, expiry, exerciseType, underlyingIdentifier, pointValue, currency, strike,

          optionType);

    store(security);

    return security;

  }

  public ManageablePortfolioNode createCommodityFutureOptionNode() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createCommodityFutureOptionSecurity());

    }

    return createNode(CommodityFutureOptionSecurity.SECURITY_TYPE, securities);

  }

  /*

  private ContinuousZeroDepositSecurity createContinuousZeroDepositSecurity() {

    final Currency currency = null;

    final ZonedDateTime startDate = null;

    final ZonedDateTime maturityDate = null;

    final double rate = 0;

    final ExternalId region = region();

    // ContinuousZeroDepositSecurity doesn't have a public constructure ?

    final ContinuousZeroDepositSecurity security = new ContinuousZeroDepositSecurity(currency, startDate, maturityDate, rate, region);

    store(security);

    return security;

  }

  */

  /*

  public void loadContinuousZeroDepositPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createContinuousZeroDepositSecurity());

    }

    load(securities);

  }

  */

  private LegacyFixedRecoveryCDSSecurity createLegacyFixedRecoveryCDSSecurity() {

    final boolean isBuy = bool();

    final ExternalId protectionSeller = ExternalId.of("protectionSeller", "Foo");

    final ExternalId protectionBuyer = ExternalId.of("protectionBuyer", "Foo");

    final ExternalId referenceEntity = ExternalId.of("referenceEntity", "Foo");

    final DebtSeniority debtSeniority = DebtSeniority.SENIOR;

    final RestructuringClause restructuringClause = RestructuringClause.NONE;

    final ExternalId regionId = region();

    final ZonedDateTime startDate = ZonedDateTime.now().minusMonths(6);

    final ZonedDateTime effectiveDate = ZonedDateTime.now().minusMonths(5);

    final ZonedDateTime maturityDate = ZonedDateTime.now().plusMonths(6);

    final StubType stubType = stubType();

    final Frequency couponFrequency = frequency();

    final DayCount dayCount = dayCount();

    final BusinessDayConvention businessDayConvention = businessDayConvention();

    final boolean immAdjustMaturityDate = bool();

    final boolean adjustEffectiveDate = bool();

    final boolean adjustMaturityDate = bool();

    final InterestRateNotional notional = interestRateNotional();

    final double recoveryRate = 0;

    final boolean includeAccruedPremium = bool();

    final boolean protectionStart = bool();

    final double parSpread = 0;

    final LegacyFixedRecoveryCDSSecurity security = new LegacyFixedRecoveryCDSSecurity(isBuy, protectionSeller, protectionBuyer, referenceEntity, debtSeniority, restructuringClause, regionId,

        startDate, effectiveDate, maturityDate, stubType, couponFrequency, dayCount, businessDayConvention, immAdjustMaturityDate, adjustEffectiveDate, adjustMaturityDate, notional, recoveryRate,

        includeAccruedPremium, protectionStart, parSpread);

    store(security);

    return security;

  }

  public ManageablePortfolioNode loadLegacyFixedRecoveryCDSPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createLegacyFixedRecoveryCDSSecurity());

    }

    return createNode(LegacyFixedRecoveryCDSSecurity.SECURITY_TYPE, securities);

   

  }

  private LegacyRecoveryLockCDSSecurity createLegacyRecoveryLockCDSSecurity() {

    final boolean isBuy = bool();

    final ExternalId protectionSeller = ExternalId.of("protectionSeller", "Foo");

    final ExternalId protectionBuyer = ExternalId.of("protectionBuyer", "Foo");

    final ExternalId referenceEntity = ExternalId.of("referenceEntity", "Foo");

    final DebtSeniority debtSeniority = DebtSeniority.SENIOR;

    final RestructuringClause restructuringClause = RestructuringClause.NONE;

    final ExternalId regionId = region();

    final ZonedDateTime startDate = ZonedDateTime.now().minusMonths(6);

    final ZonedDateTime effectiveDate = ZonedDateTime.now().minusMonths(5);

    final ZonedDateTime maturityDate = ZonedDateTime.now().plusMonths(6);

    final StubType stubType = stubType();

    final Frequency couponFrequency = frequency();

    final DayCount dayCount = dayCount();

    final BusinessDayConvention businessDayConvention = businessDayConvention();

    final boolean immAdjustMaturityDate = bool();

    final boolean adjustEffectiveDate = bool();

    final boolean adjustMaturityDate = bool();

    final InterestRateNotional notional = interestRateNotional();

    final double recoveryRate = 0;

    final boolean includeAccruedPremium = bool();

    final boolean protectionStart = bool();

    final double parSpread = 0;

    final LegacyRecoveryLockCDSSecurity security = new LegacyRecoveryLockCDSSecurity(isBuy, protectionSeller, protectionBuyer, referenceEntity, debtSeniority, restructuringClause, regionId,

        startDate, effectiveDate, maturityDate, stubType, couponFrequency, dayCount, businessDayConvention, immAdjustMaturityDate, adjustEffectiveDate, adjustMaturityDate, notional, recoveryRate,

        includeAccruedPremium, protectionStart, parSpread);

    store(security);

    return security;

  }

  public ManageablePortfolioNode loadLegacyRecoveryLockCDSPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createLegacyRecoveryLockCDSSecurity());

    }

    return createNode(LegacyRecoveryLockCDSSecurity.SECURITY_TYPE, securities);

  }

  private LegacyVanillaCDSSecurity createLegacyVanillaCDSSecurity() {

    final boolean isBuy = bool();

    final ExternalId protectionSeller = ExternalId.of("protectionSeller", "Foo");

    final ExternalId protectionBuyer = ExternalId.of("protectionBuyer", "Foo");

    final ExternalId referenceEntity = ExternalId.of("referenceEntity", "Foo");

    final DebtSeniority debtSeniority = DebtSeniority.SENIOR;

    final RestructuringClause restructuringClause = RestructuringClause.NONE;

    final ExternalId regionId = region();

    final ZonedDateTime startDate = ZonedDateTime.now().minusMonths(6);

    final ZonedDateTime effectiveDate = ZonedDateTime.now().minusMonths(5);

    final ZonedDateTime maturityDate = ZonedDateTime.now().plusMonths(6);

    final StubType stubType = stubType();

    final Frequency couponFrequency = frequency();

    final DayCount dayCount = dayCount();

    final BusinessDayConvention businessDayConvention = businessDayConvention();

    final boolean immAdjustMaturityDate = bool();

    final boolean adjustEffectiveDate = bool();

    final boolean adjustMaturityDate = bool();

    final InterestRateNotional notional = interestRateNotional();

    final boolean includeAccruedPremium = bool();

    final boolean protectionStart = bool();

    final double parSpread = 0;

    final LegacyVanillaCDSSecurity security = new LegacyVanillaCDSSecurity(isBuy, protectionSeller, protectionBuyer, referenceEntity, debtSeniority, restructuringClause, regionId,

        startDate, effectiveDate, maturityDate, stubType, couponFrequency, dayCount, businessDayConvention, immAdjustMaturityDate, adjustEffectiveDate, adjustMaturityDate, notional,

        includeAccruedPremium, protectionStart, parSpread);

    store(security);

    return security;

  }

  public ManageablePortfolioNode loadLegacyVanillaCDSPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createLegacyVanillaCDSSecurity());

    }

    return createNode(LegacyVanillaCDSSecurity.SECURITY_TYPE, securities);

  }

  public void loadLegacyCDSPortfolio() {

    loadLegacyFixedRecoveryCDSPortfolio();

    loadLegacyRecoveryLockCDSPortfolio();

    loadLegacyVanillaCDSPortfolio();

  }

  private StandardFixedRecoveryCDSSecurity createStandardFixedRecoveryCDSSecurity() {

    final boolean isBuy = bool();

    final ExternalId protectionSeller = ExternalId.of("protectionSeller", "Foo");

    final ExternalId protectionBuyer = ExternalId.of("protectionBuyer", "Foo");

    final ExternalId referenceEntity = ExternalId.of("referenceEntity", "Foo");

    final DebtSeniority debtSeniority = DebtSeniority.SENIOR;

    final RestructuringClause restructuringClause = RestructuringClause.NONE;

    final ExternalId regionId = region();

    final ZonedDateTime startDate = ZonedDateTime.now().minusMonths(6);

    final ZonedDateTime effectiveDate = ZonedDateTime.now().minusMonths(5);

    final ZonedDateTime maturityDate = ZonedDateTime.now().plusMonths(6);

    final StubType stubType = stubType();

    final Frequency couponFrequency = frequency();

    final DayCount dayCount = dayCount();

    final BusinessDayConvention businessDayConvention = businessDayConvention();

    final boolean immAdjustMaturityDate = bool();

    final boolean adjustEffectiveDate = bool();

    final boolean adjustMaturityDate = bool();

    final InterestRateNotional notional = interestRateNotional();

    final double recoveryRate = 0;

    final boolean includeAccruedPremium = bool();

    final boolean protectionStart = bool();

    final double quotedSpread = 0;

    final InterestRateNotional upfrontAmount = interestRateNotional();

    final double coupon = 0;

    final ZonedDateTime settlementDate = ZonedDateTime.now().plusMonths(7);

    final StandardFixedRecoveryCDSSecurity security = new StandardFixedRecoveryCDSSecurity(isBuy, protectionSeller, protectionBuyer, referenceEntity, debtSeniority, restructuringClause, regionId,

        startDate, effectiveDate, maturityDate, stubType, couponFrequency, dayCount, businessDayConvention, immAdjustMaturityDate, adjustEffectiveDate, adjustMaturityDate, notional, recoveryRate,

        includeAccruedPremium, protectionStart, quotedSpread, upfrontAmount);

    store(security);

    return security;

  }

  public ManageablePortfolioNode loadStandardFixedRecoveryCDSPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createStandardFixedRecoveryCDSSecurity());

    }

    return createNode(StandardFixedRecoveryCDSSecurity.SECURITY_TYPE, securities);

  }

  private StandardRecoveryLockCDSSecurity createStandardRecoveryLockCDSSecurity() {

    final boolean isBuy = bool();

    final ExternalId protectionSeller = ExternalId.of("protectionSeller", "Foo");

    final ExternalId protectionBuyer = ExternalId.of("protectionBuyer", "Foo");

    final ExternalId referenceEntity = ExternalId.of("referenceEntity", "Foo");

    final DebtSeniority debtSeniority = DebtSeniority.SENIOR;

    final RestructuringClause restructuringClause = RestructuringClause.NONE;

    final ExternalId regionId = region();

    final ZonedDateTime startDate = ZonedDateTime.now().minusMonths(6);

    final ZonedDateTime effectiveDate = ZonedDateTime.now().minusMonths(5);

    final ZonedDateTime maturityDate = ZonedDateTime.now().plusMonths(6);

    final StubType stubType = stubType();

    final Frequency couponFrequency = frequency();

    final DayCount dayCount = dayCount();

    final BusinessDayConvention businessDayConvention = businessDayConvention();

    final boolean immAdjustMaturityDate = bool();

    final boolean adjustEffectiveDate = bool();

    final boolean adjustMaturityDate = bool();

    final InterestRateNotional notional = interestRateNotional();

    final double recoveryRate = 0;

    final boolean includeAccruedPremium = bool();

    final boolean protectionStart = bool();

    final double quotedSpread = 0;

    final InterestRateNotional upfrontAmount = interestRateNotional();

    final double coupon = 0;

    final ZonedDateTime settlementDate = ZonedDateTime.now().plusMonths(7);

    final StandardRecoveryLockCDSSecurity security = new StandardRecoveryLockCDSSecurity(isBuy, protectionSeller, protectionBuyer, referenceEntity, debtSeniority, restructuringClause, regionId,

        startDate, effectiveDate, maturityDate, stubType, couponFrequency, dayCount, businessDayConvention, immAdjustMaturityDate, adjustEffectiveDate, adjustMaturityDate, notional, recoveryRate,

        includeAccruedPremium, protectionStart, quotedSpread, upfrontAmount);

    store(security);

    return security;

  }

  public ManageablePortfolioNode loadStandardRecoveryLockCDSPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createStandardRecoveryLockCDSSecurity());

    }

    return createNode(StandardRecoveryLockCDSSecurity.SECURITY_TYPE, securities);

  }

  private StandardVanillaCDSSecurity createStandardVanillaCDSSecurity() {

    final boolean isBuy = bool();

    final ExternalId protectionSeller = ExternalId.of("protectionSeller", "Foo");

    final ExternalId protectionBuyer = ExternalId.of("protectionBuyer", "Foo");

    final ExternalId referenceEntity = ExternalId.of("referenceEntity", "Foo");

    final DebtSeniority debtSeniority = DebtSeniority.SENIOR;

    final RestructuringClause restructuringClause = RestructuringClause.NONE;

    final ExternalId regionId = region();

    final ZonedDateTime startDate = ZonedDateTime.now().minusMonths(6);

    final ZonedDateTime effectiveDate = ZonedDateTime.now().minusMonths(5);

    final ZonedDateTime maturityDate = ZonedDateTime.now().plusMonths(6);

    final StubType stubType = stubType();

    final Frequency couponFrequency = frequency();

    final DayCount dayCount = dayCount();

    final BusinessDayConvention businessDayConvention = businessDayConvention();

    final boolean immAdjustMaturityDate = bool();

    final boolean adjustEffectiveDate = bool();

    final boolean adjustMaturityDate = bool();

    final InterestRateNotional notional = interestRateNotional();

    final boolean includeAccruedPremium = bool();

    final boolean protectionStart = bool();

    final double quotedSpread = 0;

    final InterestRateNotional upfrontAmount = interestRateNotional();

    final double coupon = 0;

    final ZonedDateTime settlementDate = ZonedDateTime.now().plusMonths(7);

    final boolean adjustCashSettlementDate = true;

    final StandardVanillaCDSSecurity security = new StandardVanillaCDSSecurity(isBuy, protectionSeller, protectionBuyer, referenceEntity, debtSeniority, restructuringClause, regionId,

        startDate, effectiveDate, maturityDate, stubType, couponFrequency, dayCount, businessDayConvention, immAdjustMaturityDate, adjustEffectiveDate, adjustMaturityDate, notional,

        includeAccruedPremium, protectionStart, quotedSpread, upfrontAmount, coupon, settlementDate, adjustCashSettlementDate);

    store(security);

    return security;

  }

  public ManageablePortfolioNode loadStandardVanillaCDSPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createStandardVanillaCDSSecurity());

    }

    return createNode(StandardVanillaCDSSecurity.SECURITY_TYPE, securities);

  }

  public void loadStandardCDSPortfolio() {

    loadStandardFixedRecoveryCDSPortfolio();

    loadStandardRecoveryLockCDSPortfolio();

    loadStandardVanillaCDSPortfolio();

  }

  public void loadCreditDefaultSwapPortfolio() {

    loadLegacyCDSPortfolio();

    loadStandardCDSPortfolio();

  }

  private EquitySecurity createEquitySecurity() {

    final String exchange = "exchange";

    final String exchangeCode = exchange();

    final String companyName = "companyName";

    final Currency currency = currency();

    final EquitySecurity security = new EquitySecurity(exchange, exchangeCode, companyName, currency);

    security.addExternalId(ExternalId.of(ExternalSchemes.BLOOMBERG_TICKER, "AAPL US Equity"));

    store(security);

    return security;

  }

  public ManageablePortfolioNode createEquityNode() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createEquitySecurity());

    }

    return createNode(EquitySecurity.SECURITY_TYPE, securities);

  }

  private EquityBarrierOptionSecurity createEquityBarrierOptionSecurity() {

    final OptionType optionType = optionType();

    final double strike = 0;

    final Currency currency = currency();

    final ExternalId underlyingId = createEquitySecurity().getExternalIdBundle().getExternalId(ExternalSchemes.BLOOMBERG_TICKER);

    final ExerciseType exerciseType = exerciseType();

    final Expiry expiry = expiry();

    final double pointValue = 0;

    final String exchange = exchange();

    final BarrierType barrierType = barrierType();

    final BarrierDirection barrierDirection = barrierDirection();

    final MonitoringType monitoringType = monitoringType();

    final SamplingFrequency samplingFrequency = samplingFrequency();

    final double barrierLevel = 0;

    final EquityBarrierOptionSecurity security = new EquityBarrierOptionSecurity(optionType, strike, currency, underlyingId, exerciseType, expiry, pointValue, exchange, barrierType,

          barrierDirection, monitoringType, samplingFrequency, barrierLevel);

    store(security);

    return security;

  }

  public ManageablePortfolioNode createEquityBarrierOptionNode() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createEquityBarrierOptionSecurity());

    }

    return createNode(EquityBarrierOptionSecurity.SECURITY_TYPE, securities);

  }

  private EquityIndexDividendFutureOptionSecurity createEquityIndexDividendFutureOptionSecurity() {

    final String exchange = exchange();

    final Expiry expiry = expiry();

    final ExerciseType exerciseType = exerciseType();

    final ExternalId underlyingIdentifier = ExternalId.of(ExternalSchemes.BLOOMBERG_TICKER, "US0003M Index");

    final double pointValue = 0;

    final boolean margined = bool();

    final Currency currency = currency();

    final double strike = 0;

    final OptionType optionType = optionType();

    final EquityIndexDividendFutureOptionSecurity security = new EquityIndexDividendFutureOptionSecurity(exchange, expiry, exerciseType, underlyingIdentifier, pointValue, margined, currency, strike,

        optionType);

    store(security);

    return security;

  }

  public ManageablePortfolioNode loadEquityIndexDividendFutureOptionPortfolio() {

    final Collection<ManageableSecurity> securities = new ArrayList<ManageableSecurity>(NUM_SECURITIES);

    for (int i = 0; i < NUM_SECURITIES; i++) {

      resetGenerationState(i);

      securities.add(createEquityIndexDividendFutureOptionSecurity());

    }

    return createNode(EquityIndexDividendFutureOptionSecurity.SECURITY_TYPE, securities);

  }

  private EquityIndexOptionSecurity createEquityIndexOptionSecurity() {

    final OptionType optionType = optionType();

    final double strike = 0;

    final Currency currency = currency();

    final ExternalId underlyingId = ExternalId.of(ExternalSchemes.BLOOMBERG_TICKER, "AAPL US Equity");

    final ExerciseType exerciseType = exerciseType();

    final Expiry expiry = expiry();

    final double pointValue = 0;

    final String exchange = exchange();

    final EquityIndexOptionSecurity security = new EquityIndexOptionSecurity(optionType, strike, currency, underlyingId, exerciseType, expiry, pointValue, exchange);