/**
   Copyright (C) 2009 Bojan Nikolic <bojan@bnikolic.co.uk>

   This program is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   FOR A PARTICULAR PURPOSE.

   A bare-bones example illustrating how to price American options
   with discrete dividend.

   Comments welcome at bojan@bnikolic.co.uk
*/
#include <iostream>
#include <boost/assign/list_of.hpp>

#include <ql/quantlib.hpp>

using namespace QuantLib;

struct Inputs
{
  QuantLib::Real S;
  QuantLib::Real K;
  QuantLib::Rate r;
  QuantLib::Volatility vol;

  // Dividend dates
  std::vector<Date> divdates;

  // Dividend ammounts
  std::vector<Real> divamounts;

  QuantLib::Date maturity;
  QuantLib::Date settlement;
};

void setupExample(Inputs &i)
{
  i.S=100;
  i.K=100;
  i.r=0.05;
  i.vol=0.2;

  i.divdates=boost::assign::list_of
    (Date(1, Jan, 2009))
    (Date(1, Apr, 2009))
    (Date(1, Jul, 2009))
    (Date(1, Oct, 2009))
    ;

  i.divamounts=boost::assign::list_of
    (1.0)
    (1.0)
    (1.0)
    (1.0)
    ;

  i.maturity=Date(1, Dec, 2009);
  i.settlement=Date(1, Dec, 2008);

}

void Price(const Inputs &i)
{
  Calendar calendar = TARGET();
  Settings::instance().evaluationDate() = Date(1, Dec, 2008);
  DayCounter dayCounter=Actual365Fixed();

  boost::shared_ptr<Exercise>
    americanExercise(new AmericanExercise(i.settlement,
                                          i.maturity));

  boost::shared_ptr<StrikedTypePayoff>
    payoff(new PlainVanillaPayoff(Option::Call,
                                  i.K));

  DividendVanillaOption opt(payoff,
                            americanExercise,
                            i.divdates,
                            i.divamounts);


  Handle<Quote>
    underlyingH(boost::shared_ptr<Quote>(new SimpleQuote(i.S)));

  Handle<YieldTermStructure>
    rTS(boost::shared_ptr<YieldTermStructure>(new FlatForward(i.settlement,
                                                              i.r,
                                                              dayCounter)));
  Handle<BlackVolTermStructure>
    flatVolTS(boost::shared_ptr<BlackVolTermStructure>(new BlackConstantVol(i.settlement,
                                                                            calendar,
                                                                            i.vol,
                                                                            dayCounter)));

  boost::shared_ptr<BlackScholesProcess>
    process(new BlackScholesProcess(underlyingH,
                                    rTS,
                                    flatVolTS));

  boost::shared_ptr<PricingEngine> pe
    (new FDDividendAmericanEngine(process));

  opt.setPricingEngine(pe);

  std::cout<<"NPV: "<<opt.NPV()
           <<std::endl;

}

int main(int, char* [])
{
  Inputs i;
  setupExample(i);

  Price(i);

}