#include "TreasuryYieldCurve.h"
#include <ql/quantlib.hpp>

#include <boost/timer.hpp>
#include <iostream>
#include <iomanip>
#include <fstream>

using namespace QuantLib;
using namespace std;

#if defined(QL_ENABLE_SESSIONS)
namespace QuantLib {

Integer sessionId() { return 0; }

}
#endif

int main(int, char* []) {
	try{
		boost::timer timer;
        std::cout << std::endl;

		Calendar calendar = UnitedStates(UnitedStates::GovernmentBond);;
		Date settlementDate(6, April, 2013);
		cout << "Is BD:" << calendar.isBusinessDay( settlementDate ) << std::endl ;
		cout << "Is Holiday :" << calendar.isHoliday( settlementDate ) << std::endl ;
		cout << "Is Weekend :" << calendar.isWeekend( Saturday ) << std::endl;
		cout << "Is Last BD :" << calendar.isEndOfMonth( settlementDate) << std::endl;

		settlementDate = calendar.adjust(settlementDate);

		Integer fixingDays = 1;
        Natural settlementDays = 1;

        Date todaysDate = calendar.advance(settlementDate, -fixingDays, Days);
        // nothing to do with Date::todaysDate
        Settings::instance().evaluationDate() = todaysDate;

        std::cout << "Today: " << todaysDate.weekday()
        << ", " << todaysDate << std::endl;

        std::cout << "Settlement date: " << settlementDate.weekday()
        << ", " << settlementDate << std::endl;

		 // ZC rates for the short end
		 // use the quote in wsj: http://online.wsj.com/mdc/public/page/2_3020-treasury.html#treasuryB
         Rate TB4WKsQuote=0.00045;
         Rate TB13WKsQuote=0.00065;
         Rate TB26WKSQuote=0.00095;
		 Rate TB52WKSQuote=0.00130;

		 //pointer to the quote
         boost::shared_ptr<Quote> TB4WKsRate(new SimpleQuote(TB4WKsQuote));
         boost::shared_ptr<Quote> TB13WKsRate(new SimpleQuote(TB13WKsQuote));
         boost::shared_ptr<Quote> TB26WKSRate(new SimpleQuote(TB26WKSQuote));
		 boost::shared_ptr<Quote> TB52WKSRate(new SimpleQuote(TB52WKSQuote));

		 //Treasury securities use actual/actual day count convention
		 DayCounter zcBondsDayCounter = ActualActual();
		 Date d1 (1,Oct ,2012);
		Date d2=d1 +2* Months ;
		std :: cout << " Days Between d1/ d2:" <<zcBondsDayCounter.dayCount (d1 ,d2) << std :: endl ;
		std :: cout << " Year Fraction d1 /d2:" <<zcBondsDayCounter.yearFraction (d1 ,d2) << std :: endl ;

		//pointer to the instrument
         boost::shared_ptr<RateHelper> zc4WK(new DepositRateHelper(
                 Handle<Quote>(TB4WKsRate),
                 4*Weeks, fixingDays,
                 calendar, ModifiedFollowing,
                 true, zcBondsDayCounter));
         boost::shared_ptr<RateHelper> zc13WK(new DepositRateHelper(
                 Handle<Quote>(TB13WKsRate),
                 13*Weeks, fixingDays,
                 calendar, ModifiedFollowing,
                 true, zcBondsDayCounter));
         boost::shared_ptr<RateHelper> zc26WK(new DepositRateHelper(
                 Handle<Quote>(TB26WKSRate),
                 26*Weeks, fixingDays,
                 calendar, ModifiedFollowing,
                 true, zcBondsDayCounter));
         boost::shared_ptr<RateHelper> zc52WK(new DepositRateHelper(
                 Handle<Quote>(TB52WKSRate),
                 52*Weeks, fixingDays,
                 calendar, ModifiedFollowing,
                 true, zcBondsDayCounter));

		 //set up the on the run bond
		         Real redemption = 100.0;

        const Size numberOfBonds = 6;

        Date issueDates[] = {
                Date (1, April, 2013),
                Date (15, March, 2013),
                Date (1, April, 2013),
                Date (1, April, 2013),
                Date (15, March, 2013),
				Date (15, March, 2013)
        };

        Date maturities[] = {
                Date (31, March, 2015),
                Date (15, March, 2016),
                Date (31, March, 2018),
                Date (31, March, 2020),
                Date (15, February, 2023),
				Date (15, February, 2043)
        };

        Real couponRates[] = {
                0.0025,
                0.00375,
                0.00750,
                0.01125 ,
                0.020,
				0.03125
        };

        Real marketQuotes[] = {
                100.0391 ,
                100.1484 ,
                100.3594 ,
                100.1094 ,
                102.7422 ,
				105.2422 
		};

		//pointer to the quote
        std::vector< boost::shared_ptr<SimpleQuote> > quote;
        for (Size i=0; i<numberOfBonds; i++) {
            boost::shared_ptr<SimpleQuote> cp(new SimpleQuote(marketQuotes[i]));
            quote.push_back(cp);
        }

		//pointer to the pointer of the quote
        RelinkableHandle<Quote> quoteHandle[numberOfBonds];
        for (Size i=0; i<numberOfBonds; i++) {
            quoteHandle[i].linkTo(quote[i]);
        }

        // Definition of the rate helpers
        std::vector<boost::shared_ptr<FixedRateBondHelper> > bondsHelpers;

		//pointer to the bond instruments
        for (Size i=0; i<numberOfBonds; i++) {

            Schedule schedule(issueDates[i], maturities[i], Period(Semiannual), UnitedStates(UnitedStates::GovernmentBond),
                    Unadjusted, Unadjusted, DateGeneration::Backward, false);

            boost::shared_ptr<FixedRateBondHelper> bondHelper(new FixedRateBondHelper(
                    quoteHandle[i],
                    settlementDays,
                    100.0,
                    schedule,
                    std::vector<Rate>(1,couponRates[i]),
                    ActualActual(ActualActual::Bond),
                    Unadjusted,
                    redemption,
                    issueDates[i]));

            bondsHelpers.push_back(bondHelper);
        }

		 /*********************
         **  CURVE BUILDING **
         *********************/
         // ActualActual::ISDA ensures that 30 years is 30.0
         DayCounter termStructureDayCounter = ActualActual(ActualActual::ISDA);

		 double tolerance = 1.0e-15;

         // A depo-bond curve
         std::vector<boost::shared_ptr<RateHelper> > bondInstruments;			//covers all types of bond

		 //add T-bills to the bondInstruments vector for 4-52 weeks
         bondInstruments.push_back(zc4WK);
         bondInstruments.push_back(zc13WK);
         bondInstruments.push_back(zc26WK);
		 bondInstruments.push_back(zc52WK);

		 for (Size i=0; i<numberOfBonds; i++) {
             bondInstruments.push_back(bondsHelpers[i]);
         }
	
		 //build the yieldtermstructure
    boost::shared_ptr<YieldTermStructure> bondDiscountingTermStructure(
                 new PiecewiseYieldCurve<Discount,Cubic>(
                         settlementDate, bondInstruments,
                         termStructureDayCounter,
                         tolerance));

	//bondDiscountingTermStructure->enableExtrapolation();

		std :: cout << " Zero 4W: " << bondDiscountingTermStructure -> zeroRate ( settlementDate +4* Weeks ,termStructureDayCounter , Simple ) << std :: endl ;
		std :: cout << " Zero 13W: " << bondDiscountingTermStructure -> zeroRate ( settlementDate +13* Weeks ,termStructureDayCounter , Simple ) << std :: endl ;
		std :: cout << " Zero 26W: " << bondDiscountingTermStructure -> zeroRate ( settlementDate +26* Weeks ,termStructureDayCounter , Simple ) << std :: endl ;
		std :: cout << "Zero 52W : " << bondDiscountingTermStructure -> zeroRate ( settlementDate +52* Weeks ,termStructureDayCounter , Simple ) << std :: endl ;
		std :: cout << "Zero 2 yr : " << bondDiscountingTermStructure -> zeroRate ( settlementDate +2* Years ,termStructureDayCounter , Simple ) << std :: endl ;
		std :: cout << "Zero 3 yr : " << bondDiscountingTermStructure -> zeroRate ( settlementDate +3* Years ,termStructureDayCounter , Simple ) << std :: endl ;
		std :: cout << "Zero 5 yr : " << bondDiscountingTermStructure -> zeroRate ( settlementDate +5* Years ,termStructureDayCounter , Simple ) << std :: endl ;
		
		std :: cout << "Discount 4W: " << bondDiscountingTermStructure ->discount ( settlementDate +4* Weeks , false ) << std :: endl ;
		std :: cout << "Discount 13W: " << bondDiscountingTermStructure -> discount ( settlementDate +13* Weeks , false ) << std :: endl ;
		std :: cout << "Discount 26W: " << bondDiscountingTermStructure -> discount ( settlementDate +26* Weeks , false ) << std :: endl ;
		std :: cout << "Discount 52W : " << bondDiscountingTermStructure -> discount ( settlementDate +52* Weeks , false ) << std :: endl ;
		std :: cout << "Discount 2 yr : " << bondDiscountingTermStructure -> discount ( settlementDate +2* Years , false ) << std :: endl ;
		std :: cout << "Discount 3 yr : " << bondDiscountingTermStructure -> discount ( settlementDate +3* Years , false ) << std :: endl ;
		std :: cout << "Discount 5 yr : " << bondDiscountingTermStructure -> discount ( settlementDate +5* Years , true ) << std :: endl ;
		std :: cout << "Discount 7 yr : " << bondDiscountingTermStructure -> discount ( settlementDate +7* Years , true ) << std :: endl ;
		std :: cout << "Discount 10 yr : " << bondDiscountingTermStructure -> discount ( settlementDate +10* Years , true ) << std :: endl ;
		std :: cout << "Discount 30 yr : " << bondDiscountingTermStructure -> discount ( settlementDate +30* Years , true ) << std :: endl ;

		ofstream outputFile;
		outputFile.open("c:\\temp\\discountCurve.dat");

		std::vector<double> discountCurve;
		Date maxMaturityDate(15, February, 2043);
		for(int i=0;settlementDate+i*Weeks<maxMaturityDate;i++){
			discountCurve.push_back(bondDiscountingTermStructure->discount(settlementDate + i*Weeks, false));
			outputFile << i << "|" << bondDiscountingTermStructure->discount(settlementDate + i*Weeks, false) << endl;
		}
		outputFile.close();

		ofstream outputFile1;
		outputFile1.open("c:\\temp\\zeroRate.dat");

		std::vector<double> zeroCurve;
		for(int i=0;settlementDate+i*Weeks<maxMaturityDate;i++){
			//zeroCurve.push_back(bondDiscountingTermStructure->zeroRate(settlementDate + i*Weeks ,termStructureDayCounter, Simple )) << endl;
			outputFile1 << i << " " << bondDiscountingTermStructure->zeroRate(settlementDate + i*Weeks ,termStructureDayCounter, Simple ) << endl;
		}



		cout << "hello" << endl;
		system("pause");
	}catch (std::exception& e) {
        std::cerr << e.what() << std::endl;
        return 1;
    } catch (...) {
        std::cerr << "unknown error" << std::endl;
        return 1;
    }


}