/*
 Copyright (C) 2003 Niels Elken Sønderby
 Copyright (C) 2003 Ferdinando Ametrano
 Copyright (C) 2000, 2001, 2002, 2003 RiskMap srl

 This file is part of QuantLib, a free-software/open-source library
 for financial quantitative analysts and developers - http://quantlib.org/

 QuantLib is free software: you can redistribute it and/or modify it under the
 terms of the QuantLib license.  You should have received a copy of the
 license along with this program; if not, please email ferdinando@ametrano.net
 The license is also available online at http://quantlib.org/html/license.html

 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.  See the license for more details.
*/

/*
 NesQuant is an extension to QuantLib
 http://www.nielses.dk/quantlib/nesquant
*/

/*! \file mcsvjdengine.hpp
    \brief SVJD pricing engine using Monte Carlo

    \fullpath
    nq/PricingEngines/%mcsvjdengine.cpp
*/

#ifndef nesquant_mcsvjd_engine_h
#define nesquant_mcsvjd_engine_h

#include <ql/grid.hpp>
#include <ql/MonteCarlo/montecarlomodel.hpp>
#include <ql/PricingEngines/vanillaengines.hpp>
#include <ql/TermStructures/flatforward.hpp>
#include <ql/DayCounters/Actual365.hpp>
#include <ql/Calendars/Target.hpp>

#include <nq/MonteCarlo/svjdpathgenerator.hpp>
#include <nq/PricingEngines/svjdengine.hpp>

using namespace QuantLib;
using namespace QuantLib::PricingEngines;
using namespace QuantLib::MonteCarlo;
using namespace QuantLib::TermStructures;
using namespace QuantLib::Calendars;
using namespace QuantLib::DayCounters;
using QuantLib::Math::Statistics;
using NesQuant::SVJDArguments;

namespace NesQuant {

    template<class RNG = MonteCarlo::PseudoRandom,
             class S = Statistics>
    class MCSVJDEngine
    : public GenericEngine<SVJDArguments, OptionValue>,
      public McSimulation<SingleAsset<RNG>, S> {
      public:
        void calculate() const;
        typedef typename
        McSimulation<SingleAsset<RNG>,S>::path_generator_type
            path_generator_type;
        typedef typename
        McSimulation<SingleAsset<RNG>,S>::path_pricer_type
            path_pricer_type;
        typedef typename
        McSimulation<SingleAsset<RNG>,S>::stats_type
            stats_type;
        // constructor
        MCSVJDEngine(Size maxTimeStepsPerYear,
                     bool antitheticVariate = false,
                     bool controlVariate = false,
                     Size requiredSamples = Null<int>(),
                     double requiredTolerance = Null<double>(),
                     Size maxSamples = Null<int>(),
                     long seed = 0);
        // McSimulation implementation
        Handle<path_generator_type> pathGenerator() const;
        Handle<path_pricer_type> pathPricer() const;
        TimeGrid timeGrid() const;
        // data members
        Size maxTimeStepsPerYear_;
        Size requiredSamples_, maxSamples_;
        double requiredTolerance_;
        long seed_;
    };


    // inline definitions

    template<class RNG, class S>
    inline
    MCSVJDEngine<RNG,S>::MCSVJDEngine(Size maxTimeStepsPerYear,
                                      bool antitheticVariate,
                                      bool controlVariate,
                                      Size requiredSamples,
                                      double requiredTolerance,
                                      Size maxSamples,
                                      long seed)
    : McSimulation<SingleAsset<RNG>,S>(antitheticVariate, false),
      maxTimeStepsPerYear_(maxTimeStepsPerYear),
      requiredSamples_(requiredSamples),
      maxSamples_(maxSamples),
      requiredTolerance_(requiredTolerance),
      seed_(seed) {
            QL_REQUIRE(!controlVariate,
                       "MCSVJDEngine: controlVariate not supported");
      }

    // template definitions

    template<class RNG, class S>
    inline Handle<QL_TYPENAME MCSVJDEngine<RNG,S>::path_generator_type>
    MCSVJDEngine<RNG,S>::pathGenerator() const
    {
        TimeGrid grid = timeGrid();

        typename RNG::rsg_type gen =
            RNG::make_sequence_generator(grid.size(), seed_);

        Time length = arguments_.maturity;
        Size timeSteps = grid.size();

        return Handle<path_generator_type>
                   (new GaussianSVJDPathGenerator(
                       arguments_.riskFreeRate,
                       arguments_.dividendYield,
                       arguments_.volatility,
                       arguments_.volatilityOfVolatility,
                       arguments_.steadyStateVolatility,
                       arguments_.meanReversionRate,
                       arguments_.correlationUnderlyingVolatility,
                       arguments_.jumpIntensity,
                       arguments_.jumpMean,
                       arguments_.jumpStandardDeviation,
                       length, timeSteps,
                       gen));
    }


    template<class RNG, class S>
    inline void MCSVJDEngine<RNG,S>::calculate() const {

        QL_REQUIRE(requiredTolerance_ != Null<double>() ||
                   int(requiredSamples_) != Null<int>(),
                   "MCSVJDEngine::calculate: "
                   "neither tolerance nor number of samples set");

        //! Initialize the one-factor Monte Carlo
        mcModel_ =
            Handle<MonteCarloModel<
                       SingleAsset<RNG>, S> >(
               new MonteCarloModel<
                       SingleAsset<RNG>, S>(
                   pathGenerator(), pathPricer(), S(),
                   antitheticVariate_));

        if (requiredTolerance_ != Null<double>()) {
            if (int(maxSamples_) != Null<int>())
                value(requiredTolerance_, maxSamples_);
            else
                value(requiredTolerance_);
        } else {
            valueWithSamples(requiredSamples_);
        }

        results_.value = mcModel_->sampleAccumulator().mean();
        if (RNG::allowsErrorEstimate)
            results_.errorEstimate =
                mcModel_->sampleAccumulator().errorEstimate();
    }


    template <class RNG, class S>
    inline
    Handle<QL_TYPENAME MCSVJDEngine<RNG,S>::path_pricer_type>
    MCSVJDEngine<RNG,S>::pathPricer() const {
        RelinkableHandle<TermStructure> ts(Handle<TermStructure>
            (new FlatForward(Date::todaysDate(),
                             TARGET().advance(Date::todaysDate(), 2, Days),
                             arguments_.riskFreeRate, Actual365())));

        return Handle<MCSVJDEngine<RNG,S>::path_pricer_type>(
            new EuropeanPathPricer(arguments_.type,
                               arguments_.underlying,
                               arguments_.strike,
                               ts));
    }

    template <class RNG, class S>
    inline TimeGrid MCSVJDEngine<RNG,S>::timeGrid() const {
        return TimeGrid(arguments_.maturity,
                        Size(arguments_.maturity *
                             maxTimeStepsPerYear_));
    }

}


#endif