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

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

using namespace QuantLib;
using namespace std;
using namespace boost;

#if defined(QL_ENABLE_SESSIONS)
namespace QuantLib {

Integer sessionId() { return 0; }

}
#endif

// par-rate approximation
Rate parRate(const YieldTermStructure& yts,
             const std::vector<Date>& dates,
             const DayCounter& resultDayCounter) {
    QL_REQUIRE(dates.size() >= 2, "at least two dates are required");
    Real sum = 0.0;
    Time dt;
    for (Size i=1; i<dates.size(); ++i) {
        dt = resultDayCounter.yearFraction(dates[i-1], dates[i]);
        QL_REQUIRE(dt>0.0, "unsorted dates");
        sum += yts.discount(dates[i]) * dt;
    }
    Real result = yts.discount(dates.front()) - yts.discount(dates.back());
    return result/sum;
}



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


	/////////////////***************************/////////////////////////

		Natural settlementDays = 1;
		Integer fixingDays = 1;

		DayCounter DMCalcCounter = Actual360();
		Calendar DMCalccalendar = UnitedStates(UnitedStates::GovernmentBond);

	    Date settlementDate(19, September, 2012);
        // must be a business day
        settlementDate = DMCalccalendar.adjust(settlementDate);

        Date todaysDate = DMCalccalendar.advance(settlementDate, -fixingDays, Days);
		cout << "Today is " << todaysDate << endl;
        // nothing to do with Date::todaysDate
        Settings::instance().evaluationDate() = todaysDate;



		std::vector<Date> AccuralStart;
		std::vector<double> IndexRate;
		string dummyString, line;
		double dummyNumber;
		std::ifstream AccuralStartFile, IndexRateFile;
		std::ofstream junk;
		junk.open("c:\\temp\\junk.dat");
		QuantLib::Date dd;

		AccuralStartFile.open("c:\\temp\\ASDate.dat");
		while(true){
			AccuralStartFile >> dummyString;
			if(AccuralStartFile.eof()) break;
			dd = DateParser::parse(dummyString, "mm/dd/yyyy");
			AccuralStart.push_back(dd);
			junk << dd << endl;
		}
		cout << "AccuralStartSize = " << AccuralStart.size() << endl;

		IndexRateFile.open("c:\\temp\\IndexRate.dat");
		while(true){
			IndexRateFile >> dummyNumber;
			if(IndexRateFile.eof()) break;
			IndexRate.push_back(dummyNumber);
			//junk << dummyNumber << endl;
		}
		cout << "IndexRateFileSize = " << IndexRate.size() << endl;
		junk.close();



		boost::shared_ptr<YieldTermStructure> TB13WksRateTermStructure(
			new InterpolatedZeroCurve <Linear> (
				AccuralStart, 
				IndexRate, 
				DMCalcCounter));

		Rate Spread = 0.0012;
		Rate DM = 0.0012;
		Handle<YieldTermStructure> zeroCurveHandle(TB13WksRateTermStructure);
		Handle<Quote> DMQuoteHandle(boost::shared_ptr<Quote>(new SimpleQuote(Spread)));
		boost::shared_ptr<YieldTermStructure> discountRateTermStructure(new ZeroSpreadedTermStructure(zeroCurveHandle, DMQuoteHandle));
		discountRateTermStructure->enableExtrapolation();

		Real FRNfaceAmount = 1000000;
				
		RelinkableHandle<YieldTermStructure> TreasuryTermStructure;
		const boost::shared_ptr<IborIndex> FRN13Wks(
					 new USDLibor(Period(13,Weeks),TreasuryTermStructure));
		
		FRN13Wks->addFixing(Date(30, July, 2012), 0.000950);
					 

		Schedule FRNSchedule(
			Date(31, July, 2012), 
			Date(31, July, 2014), 
			Period(Quarterly),
			UnitedStates(UnitedStates::GovernmentBond),
			Unadjusted, Unadjusted, 
			DateGeneration::Backward, 
			true);
			
		FloatingRateBond FRN(
			settlementDays,
			FRNfaceAmount,
			FRNSchedule,
			FRN13Wks,
			Actual360(), 
			ModifiedFollowing,
			Natural(2),
			// Gearings
			std::vector<Real>(1, 1.0),
			// Spreads
			std::vector<Rate>(1, 0.0012),
			// Caps
			std::vector<Rate>(),
			// Floors
			std::vector<Rate>(),
			// Fixing in arrears
			true,
			Real(100.0),
			Date(31, July, 2012));
			
	    RelinkableHandle<YieldTermStructure> discountRateTermStructureHandle;
		boost::shared_ptr<PricingEngine> FRNEngine(new DiscountingBondEngine(discountRateTermStructureHandle));

		FRN.setPricingEngine(FRNEngine);

		// Coupon pricers
        boost::shared_ptr<IborCouponPricer> FRNpricer(new BlackIborCouponPricer);

		// optionLet volatilities
         Volatility FRNvolatility = 0.0;
         Handle<OptionletVolatilityStructure> FRNvol;
         FRNvol = Handle<OptionletVolatilityStructure>(
                 boost::shared_ptr<OptionletVolatilityStructure>(new
                         ConstantOptionletVolatility(
                                 settlementDays,
                                 DMCalccalendar,
                                 ModifiedFollowing,
                                 FRNvolatility,
                                 Actual365Fixed())));

         FRNpricer->setCapletVolatility(FRNvol);
		 //void setCouponPricer(const Leg& leg, const boost::shared_ptr<FloatingRateCouponPricer>&);
		 //to set the price using setCouponPricer
         setCouponPricer(FRN.cashflows(),FRNpricer);		
		 
         // Yield curve bootstrapping
         discountRateTermStructureHandle.linkTo(discountRateTermStructure);
		 
		 TreasuryTermStructure.linkTo(discountRateTermStructure);
		 
		Size FRNwidths[] = { 18, 10, 10, 10 };
		std::cout << std::setw(FRNwidths[0]) << "FRN Net present value" << std::setw(FRNwidths[3]) << FRN.NPV() << std::endl;
		std::cout << std::setw(FRNwidths[0]) << "FRN Clean price" << std::setw(FRNwidths[2]) << FRN.cleanPrice() << std::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;
    }


}