package examples;

import org.quantlib.Actual365Fixed;
import org.quantlib.ActualActual;
import org.quantlib.BusinessDayConvention;
import org.quantlib.CPI;
import org.quantlib.CPIBond;
import org.quantlib.CPISwap;
import org.quantlib.Calendar;
import org.quantlib.CashFlow;
import org.quantlib.Compounding;
import org.quantlib.Date;
import org.quantlib.DateGeneration;
import org.quantlib.DateVector;
import org.quantlib.Datum;
import org.quantlib.DayCounter;
import org.quantlib.DiscountingBondEngine;
import org.quantlib.DiscountingSwapEngine;
import org.quantlib.DoubleVector;
import org.quantlib.Frequency;
import org.quantlib.GBPLibor;
import org.quantlib.IborIndex;
import org.quantlib.InterpolatedZeroLinear;
import org.quantlib.Leg;
import org.quantlib.Linear;
import org.quantlib.Month;
import org.quantlib.Period;
import org.quantlib.PiecewiseZeroInflationLinear;
import org.quantlib.RelinkableYieldTermStructureHandle;
import org.quantlib.RelinkableZeroInflationTermStructureHandle;
import org.quantlib.Schedule;
import org.quantlib.Settings;
import org.quantlib.TimeUnit;
import org.quantlib.UKRPI;
import org.quantlib.UnitedKingdom;
import org.quantlib.YieldTermStructure;
import org.quantlib.YieldTermStructureHandle;
import org.quantlib.ZeroCouponInflationSwapHelper;
import org.quantlib.ZeroHelper;
import org.quantlib.ZeroHelperVector;
import org.quantlib.ZeroInflationIndex;
import org.quantlib.ZeroInflationTermStructure;
import org.quantlib._CPISwap;

public class CPIBonds {

	/**
	 * @param args
	 */
    static {
        try {
            System.loadLibrary("QuantLibJNI"); 
        } catch (RuntimeException e) {
            e.printStackTrace();
        }
    }
 
   
	public static void main(String[] args) throws Exception {
		// common data
        long beginTime = System.currentTimeMillis();
	//	Date startDate;

		DateVector zciisD = new DateVector();
		DoubleVector zciisR = new DoubleVector();

		Integer zciisDataLength;
		// option variables
		DoubleVector nominals = new DoubleVector();  // 1M
		nominals.add(100);
		Frequency frequency = Frequency.Annual;
		// usual setup
		double volatility = 0.01;
		Integer length = 7;
		Calendar calendar = new UnitedKingdom();
		BusinessDayConvention convention = BusinessDayConvention.ModifiedFollowing;
		Date today = new Date(25, Month.November, 2009);
		Date evaluationDate = calendar.adjust(today);
		Settings.instance().setEvaluationDate(evaluationDate);
		Integer settlementDays = 0;
		Integer fixingDays = 0;
		Date settlement = calendar.advance(today,settlementDays,TimeUnit.Days);
  	//	startDate = settlement;
		// uk rpi index

		Date from = new Date(20, Month.July, 2007);
		//Date from(20, July, 2008);
		Date to = new Date(20, Month.November, 2009);
		Schedule rpiSchedule = new Schedule(from, to, new Period(1, TimeUnit.Months),new UnitedKingdom(), 
				BusinessDayConvention.ModifiedFollowing,BusinessDayConvention.ModifiedFollowing,DateGeneration.Rule.Forward, false);
	
		double fixData[] = { 
			206.1, 207.3, 208.0, 208.9, 209.7, 210.9,
			209.8, 211.4, 212.1, 214.0, 215.1, 216.8,
			216.5, 217.2, 218.4, 217.7, 216,
			212.9, 210.1, 211.4, 211.3, 211.5,
			212.8, 213.4, 213.4, 213.4, 214.4,
			-999.0, -999.0 };

			// link from cpi index to cpi TS
			RelinkableZeroInflationTermStructureHandle hcpi = new RelinkableZeroInflationTermStructureHandle();
			boolean interp = false;// this MUST be false because the observation lag is only 2 months
			// for ZCIIS; but not for contract if the contract uses a bigger lag.
			UKRPI ii = new UKRPI(interp, hcpi);
			for (Integer i=0; i<rpiSchedule.size();i++) {
				ii.addFixing(rpiSchedule.date(i), (fixData[i]));// force overwrite in case multiple use
			};
			
			Datum datum1 = new Datum();
			datum1.setDate(new Date(26, Month.November, 2009));
			datum1.setRate(0.475);
			Datum datum2 = new Datum();
			datum2.setDate(new Date( 2, Month.December, 2009));
			datum2.setRate( 0.47498);			
			Datum nominalDatum[] = {datum1, datum2};
			
			Object[] nominalData[] = {
					new Object[]{new Date(26, Month.November, 2009), 0.475   },
					new Object[]{new Date( 2, Month.December, 2009), 0.47498 },
					new Object[]{new Date(29, Month.December, 2009), 0.49988 },
					new Object[]{new Date(25, Month.February, 2010), 0.59955 },
					new Object[]{new Date(18, Month.March, 2010), 0.65361 },
					new Object[]{new Date(25, Month.May, 2010), 0.82830 },
					//	{ Date(17, June, 2010), 0.7 },	// can't boostrap with this data point
					new Object[]{new Date(16, Month.September, 2010),   0.78960 },
					new Object[]{new Date(16, Month.December, 2010),    0.93762 },
					new Object[]{new Date(17, Month.March, 2011),       1.12037 },
					new Object[]{new Date(16, Month.June, 2011),        1.31308 },
					new Object[]{new Date(22, Month.September, 2011),   1.52011 },
					new Object[]{new Date(25, Month.November, 2011),	1.78399 },
					new Object[]{new Date(26, Month.November, 2012),	2.41170 },
					new Object[]{new Date(25, Month.November, 2013),	2.83935 },
					new Object[]{new Date(25, Month.November, 2014),	3.1288  },
					new Object[]{new Date(25, Month.November, 2015),	3.34298 },
					new Object[]{new Date(25, Month.November, 2016),	3.50632 },
					new Object[]{new Date(27, Month.November, 2017),	3.63666 },
					new Object[]{new Date(26, Month.November, 2018),	3.74723 },
					new Object[]{new Date(25, Month.November, 2019),	3.83988 },
					new Object[]{new Date(25, Month.November, 2021),	4.00508 },
					new Object[]{new Date(25, Month.November, 2024),	4.16042 },
					new Object[]{new Date(26, Month.November, 2029),	4.15577 },
					new Object[]{new Date(27, Month.November, 2034),	4.04933 },
					new Object[]{new Date(25, Month.November, 2039),	3.95217 },
					new Object[]{new Date(25, Month.November, 2049),	3.80932 },
					new Object[]{new Date(25, Month.November, 2059),	3.80849 },
					new Object[]{new Date(25, Month.November, 2069),	3.72677 },
					new Object[]{new Date(27, Month.November, 2079),	3.63082 }
			};
			Integer nominalDataLength = 30-1;
			DayCounter dcNominal = new ActualActual();
			DateVector nomD = new DateVector();
			DoubleVector nomR = new DoubleVector();
			for (Integer i = 0; i < nominalDataLength; i++) {
				nomD.add((Date)nominalData[i][0]);
				Double a = (Double) nominalData[i][1];
				nomR.add(a.doubleValue()/100.0);
			}
			YieldTermStructure nominal = new InterpolatedZeroLinear(nomD,nomR,dcNominal);
			RelinkableYieldTermStructureHandle nominalTS = new RelinkableYieldTermStructureHandle();
			nominalTS.linkTo(nominal);

			Period observationLag = new Period(2,TimeUnit.Months);
			Period contractObservationLag = new Period(3,TimeUnit.Months);
			CPI.InterpolationType contractObservationInterpolation = CPI.InterpolationType.Flat;

			Object[] zciisData[] = {
				new Object[]{new Date(25, Month.November, 2010), 3.0495 },
				new Object[]{new Date(25, Month.November, 2011), 2.93 },
				new Object[]{new Date(26, Month.November, 2012), 2.9795 },
				new Object[]{new Date(25, Month.November, 2013), 3.029 },
				new Object[]{new Date(25, Month.November, 2014), 3.1425 },
				new Object[]{new Date(25, Month.November, 2015), 3.211 },
				new Object[]{new Date(25, Month.November, 2016), 3.2675 },
				new Object[]{new Date(25, Month.November, 2017), 3.3625 },
				new Object[]{new Date(25, Month.November, 2018), 3.405 },
				new Object[]{new Date(25, Month.November, 2019), 3.48 },
				new Object[]{new Date(25, Month.November, 2021), 3.576 },
				new Object[]{new Date(25, Month.November, 2024), 3.649 },  
				new Object[]{new Date(26, Month.November, 2029), 3.751 },  
				new Object[]{new Date(27, Month.November, 2034), 3.77225 },  
				new Object[]{new Date(25, Month.November, 2039), 3.77 },  
				new Object[]{new Date(25, Month.November, 2049), 3.734 },
				new Object[]{new Date(25, Month.November, 2059), 3.714 }
			};
			zciisDataLength = 17;
			DayCounter dcZCIIS = new ActualActual();
			for (Integer i = 0; i < zciisDataLength; i++) {
				zciisD.add((Date)zciisData[i][0]);
				Double a = (Double) zciisData[i][1];
				zciisR.add(a.doubleValue()/100.0);
			}
	 
			// now build the helpers base on ZeroCouponInflationSwap
			ZeroHelperVector helpers = new ZeroHelperVector();
			for (Integer i=0; i<zciisDataLength; i++) {
				Date maturity = (Date)zciisData[i][0];
				Double quote = (Double) zciisData[i][1];
				ZeroHelper anInstrument = new ZeroCouponInflationSwapHelper(
					quote.doubleValue()/100.0, observationLag, maturity,
					calendar, convention, dcZCIIS, ii);
				helpers.add(anInstrument);
			}			
			

			// we can use historical or first ZCIIS for this
			// we know historical is WAY off market-implied, so use market implied flat.
			Double b = (Double)zciisData[0][1];
			double baseZeroRate = b.doubleValue()/100.0;
			double accuracy = 1.0e-12;
			//ii.frequency() = Monthly
			//ii.Interpolated()= false
			PiecewiseZeroInflationLinear pCPIts = new PiecewiseZeroInflationLinear(
				evaluationDate, calendar, dcZCIIS, observationLag,
				ii.frequency(),ii.interpolated(), baseZeroRate,
				(YieldTermStructureHandle)nominalTS, helpers, accuracy, new Linear());
			// pCPIts.recalculate();
			ZeroInflationTermStructure cpiTS = (ZeroInflationTermStructure) pCPIts;
// make sure that the index has the latest zero inflation term structure

			_CPISwap.Type typecpi = CPISwap.Payer;
			double rnominal = 1000000.0;
			boolean subtractInflationNominal = true;
			// float+spread leg
			double spread = 0.0;
			DayCounter floatDayCount = new Actual365Fixed();
			BusinessDayConvention floatPaymentConvention = BusinessDayConvention.ModifiedFollowing;
			fixingDays = 0;
			IborIndex floatIndex = new GBPLibor(new Period(6,TimeUnit.Months), 
				nominalTS);

			// fixed x inflation leg
			double fixedRate = 0.1;//1% would be 0.01
			double baseCPI = 206.1; // would be 206.13871 if we were interpolating
			DayCounter fixedDayCount = new Actual365Fixed();
			BusinessDayConvention fixedPaymentConvention = BusinessDayConvention.ModifiedFollowing;
			Calendar fixedPaymentCalendar = new UnitedKingdom();
			ZeroInflationIndex fixedIndex = ii;
			
			CPI.InterpolationType observationInterpolation = contractObservationInterpolation;

			// set the schedules
			Date startDate = new Date(2, Month.October, 2007);
			Date endDate = new Date(2, Month.October, 2052);
			Schedule floatSchedule = new Schedule(startDate, endDate, new Period(6, TimeUnit.Months),new UnitedKingdom(), 
					floatPaymentConvention,floatPaymentConvention,DateGeneration.Rule.Backward, false);
			
			Schedule fixedSchedule = new Schedule(startDate, endDate, new Period(6, TimeUnit.Months),new UnitedKingdom(), 
					BusinessDayConvention.Unadjusted,BusinessDayConvention.Unadjusted,DateGeneration.Rule.Backward, false);

			CPISwap zisV = new CPISwap(typecpi, rnominal, subtractInflationNominal,
				spread, floatDayCount, floatSchedule,
				floatPaymentConvention, fixingDays, floatIndex,
				fixedRate, baseCPI , fixedDayCount, fixedSchedule,
				fixedPaymentConvention, contractObservationLag, 
				fixedIndex, observationInterpolation);
			Date baseDate = floatSchedule.date(0).subtract(contractObservationLag);
			Date asofDate = Settings.instance().getEvaluationDate();	

			double floatFix[] = {0.06255,0.05975,0.0637,0.018425,0.0073438,-1,-1};
			double cpiFix[] = {211.4,217.2,211.4,213.4,-2,-2};
			
			for(Integer i=0;i<floatSchedule.size(); i++){
				if (floatSchedule.date(i).serialNumber() < evaluationDate.serialNumber()) {
					floatIndex.addFixing(floatSchedule.date(i), floatFix[i],true);//true=overwrite
				}

				Leg zil = zisV.cpiLeg();
				CashFlow zic = zil.get(i);
				boolean forceOverwrite = true;
				if (zic.isNull()==false) {
					if (zic.date().serialNumber() < (evaluationDate.subtract(new Period(1,TimeUnit.Months)).serialNumber())) {
						fixedIndex.addFixing(zic.date(), cpiFix[i], forceOverwrite);
					}
				}
			}


			// simple structure so simple pricing engine - most work done by index 
			DiscountingSwapEngine dse = new DiscountingSwapEngine(nominalTS);
			zisV.setPricingEngine(dse);
			
			// now do the bond equivalent
			DoubleVector fixedRates = new DoubleVector();
			fixedRates.add(fixedRate);
			settlementDays = 1;// cannot be zero!
			
			boolean growthOnly = true;
			CPIBond cpiB =  new CPIBond(settlementDays, rnominal, growthOnly,
				baseCPI, contractObservationLag, fixedIndex,
				observationInterpolation, fixedSchedule,
				fixedRates, fixedDayCount, fixedPaymentConvention, startDate);
			DiscountingBondEngine dbe = new DiscountingBondEngine(nominalTS);
			cpiB.setPricingEngine(dbe);
			
			double npv = cpiB.NPV();
			double yd = cpiB.yield(fixedDayCount, Compounding.Continuous, frequency);
			double pr = cpiB.cleanPrice();
			double dpr = cpiB.dirtyPrice();
			

			System.out.println("NPV: " + npv
				+ "\nYield: " + yd
				+ "\nClean price: " + pr
				+ "\nDirty Price: " + dpr);


	        long msecs = (System.currentTimeMillis()- beginTime);
	        System.out.println("Run completed in "+msecs+" ms.");

	}

}