/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*
 Copyright (C) 2008 Roland Lichters
 Copyright (C) 2021 Lew Wei Hao

 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
 <quantlib-dev@lists.sf.net>. The license is also available online at
 <https://www.quantlib.org/license.shtml>.

 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.
*/

/*! \file riskybondengine.hpp
    \brief risky bond engine
*/

#ifndef quantlib_risky_bond_engine_hpp
#define quantlib_risky_bond_engine_hpp

#include <ql/instruments/bond.hpp>
#include <ql/termstructures/yieldtermstructure.hpp>
#include <ql/termstructures/defaulttermstructure.hpp>
#include <ql/handle.hpp>

namespace QuantLib {

    //! Risky pricing engine for bonds
    /*! The value of each cashflow is contingent to survival, i.e., the knockout
        probability is considered.

        In each of the \f$n\f$ coupon periods, we can calculate the value
        in the case of survival and default, assuming that the issuer
        can only default in the middle of a coupon period. We denote this time
        \f$T_{i}^{mid}=\frac{T_{i-1}+T_{i}}{2}\f$.

        Given survival we receive the full cash flow (both coupons and notional).
        The time \f$t\f$ value of these payments are given by
        \f[
            \sum_{i=1}^{n}CF_{i}P(t,T_{i})Q(T_{i}<\tau)
        \f]
        where \f$P(t,T)\f$ is the time \f$T\f$ discount bond
        and \f$Q(T<\tau)\f$ is the time \f$T\f$ survival probability.
        \f$n\f$ is the number of coupon periods. This takes care of the payments
        in the case of survival.

        Given default we receive only a fraction of the notional at default.
        \f[
            \sum_{i=1}^{n}Rec N(T_{i}^{mid}) P(t,T_{i}^{mid})Q(T_{i-1}<\tau\leq T_{i})
        \f]
        where \f$Rec\f$ is the recovery rate and \f$N(T)\f$ is the time T notional. The default probability can be
        rewritten as
        \f[
            Q(T_{i-1}<\tau\leq T_{i})=Q(T_{i}<\tau)-Q(T_{i-1}<\tau)=(1-Q(T_{i}\geq\tau))-(1-Q(T_{i-1}\geq\tau))=Q(T_{i-1}\geq\tau)-Q(T_{i}\geq\tau)
        \f]
    */
    class RiskyBondEngine : public Bond::engine {
      public:
        RiskyBondEngine(Handle<DefaultProbabilityTermStructure> defaultTS,
                        Real recoveryRate,
                        Handle<YieldTermStructure> yieldTS);
        void calculate() const override;
        Handle<DefaultProbabilityTermStructure> defaultTS() const;
        Real recoveryRate() const;
        Handle<YieldTermStructure> yieldTS() const;
      private:
        Handle<DefaultProbabilityTermStructure> defaultTS_;
        Real recoveryRate_;
        Handle<YieldTermStructure> yieldTS_;
    };


    inline Handle<DefaultProbabilityTermStructure> RiskyBondEngine::defaultTS() const {
        return defaultTS_;
    }

    inline Real RiskyBondEngine::recoveryRate() const { return recoveryRate_; }

    inline Handle<YieldTermStructure> RiskyBondEngine::yieldTS() const { return yieldTS_; }

}

#endif
