package com.opengamma.sesame.credit.measures;

import static org.mockito.Matchers.any;
import static org.mockito.Mockito.when;
import static org.powermock.api.mockito.PowerMockito.mock;
import static org.testng.AssertJUnit.assertTrue;

import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.testng.PowerMockTestCase;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;

import com.opengamma.analytics.financial.credit.isdastandardmodel.CDSAnalytic;
import com.opengamma.core.link.SecurityLink;
import com.opengamma.financial.analytics.isda.credit.CreditCurveData;
import com.opengamma.financial.analytics.isda.credit.CreditCurveDataKey;
import com.opengamma.financial.security.cds.CDSIndexComponentBundle;
import com.opengamma.financial.security.cds.CreditDefaultSwapIndexComponent;
import com.opengamma.financial.security.credit.IndexCDSDefinitionSecurity;
import com.opengamma.financial.security.credit.IndexCDSSecurity;
import com.opengamma.financial.security.credit.LegacyCDSSecurity;
import com.opengamma.financial.security.credit.StandardCDSSecurity;
import com.opengamma.financial.security.swap.InterestRateNotional;
import com.opengamma.id.ExternalId;
import com.opengamma.id.ExternalIdBundle;
import com.opengamma.sesame.Environment;
import com.opengamma.sesame.credit.CdsData;
import com.opengamma.sesame.credit.CreditPricingSampleData;
import com.opengamma.sesame.credit.IsdaCompliantCreditCurveFn;
import com.opengamma.sesame.credit.IsdaCreditCurve;
import com.opengamma.sesame.credit.converter.IndexCdsConverterFn;
import com.opengamma.sesame.credit.converter.LegacyCdsConverterFn;
import com.opengamma.sesame.credit.converter.StandardCdsConverterFn;
import com.opengamma.sesame.credit.market.IndexCdsMarketDataResolverFn;
import com.opengamma.sesame.credit.market.LegacyCdsMarketDataResolverFn;
import com.opengamma.sesame.credit.market.StandardCdsMarketDataResolverFn;
import com.opengamma.util.money.Currency;
import com.opengamma.util.result.Result;

/**
 * Tests {@link AbstractCreditRiskMeasureFn} flow.
 */
@PrepareForTest(IsdaCreditCurve.class)
public class AbstractCreditRiskMeasureFnTest extends PowerMockTestCase {
  
  
  private AbstractCreditRiskMeasureFn<RiskResult> _creditRiskMeasureFn;
  private Environment _env;
  private LegacyCDSSecurity _legCds;
  private StandardCDSSecurity _cds;
  private IndexCDSSecurity _cdx;
  private IndexCDSDefinitionSecurity _cdxDef;
  private SecurityLink<IndexCDSDefinitionSecurity> _cdxDefLink;
  
  //standard cds fields:
  private final InterestRateNotional _notional = new InterestRateNotional(Currency.USD, 1000000);
  private final double _coupon = 0.01;

  //cdx fields used in the AbstractCreditRiskMeasureFn
  private final ExternalId _externalId = ExternalId.of("test", "123");
  private final CreditDefaultSwapIndexComponent _component =
      new CreditDefaultSwapIndexComponent(_externalId.getValue(),
                                          _externalId,
                                          0.95,
                                          _externalId);
  private final CDSIndexComponentBundle _bundle = CDSIndexComponentBundle.of(_component);

  @SuppressWarnings("unchecked")
  @BeforeMethod
  public void beforeMethod() {
    _env = mock(Environment.class);
    _legCds = mock(LegacyCDSSecurity.class);
    _cds = mock(StandardCDSSecurity.class);
    _cdx = mock(IndexCDSSecurity.class);
    _cdxDefLink = mock(SecurityLink.class);
    _cdxDef = mock(IndexCDSDefinitionSecurity.class);

    ExternalIdBundle idBundle = ExternalIdBundle.of(ExternalId.of("test", "1"));

    when(_legCds.getNotional()).thenReturn(_notional);
    when(_legCds.getExternalIdBundle()).thenReturn(idBundle);
    when(_legCds.getCoupon()).thenReturn(_coupon);
    when(_cds.getNotional()).thenReturn(_notional);
    when(_cds.getExternalIdBundle()).thenReturn(idBundle);
    when(_cds.getCoupon()).thenReturn(_coupon);
    when(_cdx.getNotional()).thenReturn(_notional);
    when(_cdx.getExternalIdBundle()).thenReturn(idBundle);
    when(_cdx.getUnderlyingIndex()).thenReturn(_cdxDefLink);
    when(_cdxDefLink.resolve()).thenReturn(_cdxDef);
    when(_cdxDef.getCoupon()).thenReturn(_coupon);
    when(_cdxDef.getComponents()).thenReturn(_bundle);

    LegacyCdsConverterFn legacyCdsConverter = mock(LegacyCdsConverterFn.class);
    StandardCdsConverterFn standardCdsConverter = mock(StandardCdsConverterFn.class);
    IndexCdsConverterFn indexCdsConverter = mock(IndexCdsConverterFn.class);
    Result<CDSAnalytic> result = mock(Result.class);
    when(result.isSuccess()).thenReturn(true);
    when(legacyCdsConverter.toCdsAnalytic(any(Environment.class), any(LegacyCDSSecurity.class), any(IsdaCreditCurve.class))).thenReturn(result);
    when(indexCdsConverter.toCdsAnalytic(any(Environment.class), any(IndexCDSSecurity.class), any(IsdaCreditCurve.class))).thenReturn(result);
    when(standardCdsConverter.toCdsAnalytic(any(Environment.class), any(StandardCDSSecurity.class), any(IsdaCreditCurve.class))).thenReturn(result);
    
    final Result<CreditCurveDataKey> keyResult = mock(Result.class);
    when(keyResult.isSuccess()).thenReturn(true);
    //can't use mockito for these calls due to a limitation resolving calls via
    //interfaces with generic params (i.e. CreditMarketDataResolverFn)
    class StandardCdsMdResolverMock implements StandardCdsMarketDataResolverFn {
      
      @Override
      public Result<CreditCurveDataKey> resolve(Environment env, StandardCDSSecurity security) {
        return keyResult;
      }
    }
    
    class LegacyCdsMdResolverMock implements LegacyCdsMarketDataResolverFn {
      
      @Override
      public Result<CreditCurveDataKey> resolve(Environment env, LegacyCDSSecurity security) {
        return keyResult;
      }
    }

    class IndexCdsMdResolverMock implements IndexCdsMarketDataResolverFn {

      @Override
      public Result<CreditCurveDataKey> resolve(Environment env, IndexCDSSecurity security) {
        return keyResult;
      }
    }
    
    IsdaCompliantCreditCurveFn curveFn = mock(IsdaCompliantCreditCurveFn.class);
    Result<IsdaCreditCurve> isdaCurveResult = mock(Result.class);
    when(isdaCurveResult.isSuccess()).thenReturn(true);
    IsdaCreditCurve curve = mock(IsdaCreditCurve.class);
    when(isdaCurveResult.getValue()).thenReturn(curve);
    CreditCurveData data = CreditPricingSampleData.createSingleNameCreditCurveData();
    when(curve.getCurveData()).thenReturn(data);
    when(curveFn.buildIsdaCompliantCreditCurve(any(Environment.class), any(CreditCurveDataKey.class))).thenReturn(isdaCurveResult);
    
    _creditRiskMeasureFn = new AbstractCreditRiskMeasureFn<RiskResult>(legacyCdsConverter,
                                                      standardCdsConverter,
                                                      indexCdsConverter,
                                                      new IndexCdsMdResolverMock(),
                                                      new StandardCdsMdResolverMock(), 
                                                      new LegacyCdsMdResolverMock(),
                                                      curveFn) {

      @Override
      protected Result<RiskResult> price(CdsData cdsData, CDSAnalytic cdsAnalytic, IsdaCreditCurve curve) {
        RiskResult result = new RiskResult();
        result._cdsData = cdsData;
        result._cdsAnalytic = cdsAnalytic;
        result._curve = curve;
        return Result.success(result);
      }
    };
    
  }
  
  class RiskResult {
    CdsData _cdsData;
    CDSAnalytic _cdsAnalytic;
    IsdaCreditCurve _curve;
  }

  @Test
  public void priceLegacyCds() {
    Result<RiskResult> result = _creditRiskMeasureFn.priceLegacyCds(_env, _legCds);
    assertTrue(result.isSuccess());
  }

  @Test
  public void priceStandardCds() {
    Result<RiskResult> result = _creditRiskMeasureFn.priceStandardCds(_env, _cds);
    assertTrue(result.isSuccess());
  }

  @Test
  public void priceIndexCds() {
    Result<RiskResult> result = _creditRiskMeasureFn.priceIndexCds(_env, _cdx);
    assertTrue(result.isSuccess());
  }
}