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

/*

 Copyright (C) 2016 Quaternion Risk Management Ltd

 Copyright (C) 2025 Paolo D'Elia

 Copyright (C) 2026 Kyrylo Protsenko

 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 constnotionalcrosscurrencybasisswap.hpp

    \brief Cross-currency basis swap

*/

#ifndef quantlib_cross_currency_basis_swap_hpp

#define quantlib_cross_currency_basis_swap_hpp

#include <ql/indexes/iborindex.hpp>

#include <ql/cashflows/iborcoupon.hpp>

#include <ql/cashflows/stubiborcoupon.hpp>

#include <ql/cashflows/rateaveraging.hpp>

#include <ql/optional.hpp>

#include <ql/time/schedule.hpp>

#include <ql/instruments/constnotionalcrosscurrencyswap.hpp>

namespace QuantLib {

//! Cross-currency basis swap

/*! The first leg holds the pay currency cashflows and second leg holds

    the receive currency cashflows.

    \ingroup instruments

*/

class ConstNotionalCrossCurrencyBasisSwap : public ConstNotionalCrossCurrencySwap {

  public:

    class arguments;

    class results;

    //! \name Constructors

    //@{

    /*!

        \brief Constructs a cross-currency basis swap.

        First leg holds the pay currency cashflows and the second leg holds the receive currency cashflows.

        Payment lags apply only to coupon payments.  Notional exchanges remain

        on the effective and maturity dates, unless paymentLagOnNotionalExchanges

        is set, in which case each leg's exchanges are lagged by that leg's

        coupon payment lag: the final exchange settles together with the final

        coupon and the initial exchange falls on the lagged settlement date.

        \param payNominal         Notional amount for the pay leg.

        \param payCurrency        Currency of the pay leg.

        \param paySchedule        Payment schedule for the pay leg.

        \param payIndex           Floating rate index for the pay leg.

        \param paySpread          Spread over the floating rate for the pay leg.

        \param payGearing         Gearing factor for the pay leg.

        \param recNominal         Notional amount for the receive leg.

        \param recCurrency        Currency of the receive leg.

        \param recSchedule        Payment schedule for the receive leg.

        \param recIndex           Floating rate index for the receive leg.

        \param recSpread          Spread over the floating rate for the receive leg.

        \param recGearing         Gearing factor for the receive leg.

        \param payPaymentLag      Coupon payment lag in days for the pay leg (default: 0).

        \param recPaymentLag      Coupon payment lag in days for the receive leg (default: 0).

        \param payCompoundSpread  Whether to compound the spread daily for the pay leg if overnight (default: false).

        \param payLookbackDays    Lookback days for the pay leg if overnight (default: null).

        \param payObservationShift  Whether the observation shift is applied for the pay leg if overnight (default: false).

        \param payLockoutDays     Lockout period (in business days) for the pay leg if overnight (default: 0).

        \param payAveragingMethod   Averaging method for the pay leg if overnight (default: compounding).

        \param recCompoundSpread  Whether to compound the spread daily for the receive leg if overnight (default: false).

        \param recLookbackDays    Lookback days for the receive leg if overnight (default: null).

        \param recObservationShift  Whether the observation shift is applied for the receive leg if overnight (default: false).

        \param recLockoutDays     Lockout period (in business days) for the receive leg if overnight (default: 0).

        \param recAveragingMethod   Averaging method for the receive leg if overnight (default: compounding).

        \param telescopicValueDates Flag indicating whether telescopic value dates are used if overnight (default: false).

        \param useIndexedCoupons If provided, overrides the global IborCoupon setting for both legs.

        \param paymentLagOnNotionalExchanges Whether the notional exchanges are lagged by each leg's coupon payment lag (default: false).

        \param payStubIndexSelection  Index selection applied to irregular coupons

                                   of the pay leg when it is an Ibor leg (see

                                   StubIndexSelection).  The default prices broken

                                   periods off the leg's own index.

        \param recStubIndexSelection  As payStubIndexSelection, for the receive leg.

    */

    ConstNotionalCrossCurrencyBasisSwap(

        Real payNominal, Currency  payCurrency, Schedule  paySchedule,

        const ext::shared_ptr<IborIndex>& payIndex, Spread paySpread, Real payGearing, Real recNominal,

        Currency  recCurrency, Schedule  recSchedule, const ext::shared_ptr<IborIndex>& recIndex,

        Spread recSpread, Real recGearing, Integer payPaymentLag = 0, Integer recPaymentLag = 0,

        bool payCompoundSpread = false, Natural payLookbackDays = Null<Natural>(), bool payObservationShift = false,

        Natural payLockoutDays = 0, RateAveraging::Type payAveragingMethod = RateAveraging::Compound,

        bool recCompoundSpread = false, Natural recLookbackDays = Null<Natural>(), bool recObservationShift = false,

        Natural recLockoutDays = 0, RateAveraging::Type recAveragingMethod = RateAveraging::Compound,

        bool telescopicValueDates = false,

        std::optional<bool> useIndexedCoupons = std::nullopt,

        bool paymentLagOnNotionalExchanges = false,

        StubIndexSelection payStubIndexSelection = {},

        StubIndexSelection recStubIndexSelection = {});

    //@}

    //! \name Instrument interface

    //@{

    void setupArguments(PricingEngine::arguments* args) const override;

    void fetchResults(const PricingEngine::results*) const override;

    //@}

    //! \name Inspectors

    //@{

    Real payNominal() const { return payNominal_; }

    const Currency& payCurrency() const { return payCurrency_; }

    const Schedule& paySchedule() const { return paySchedule_; }

    const ext::shared_ptr<IborIndex>& payIndex() const { return payIndex_; }

    Spread paySpread() const { return paySpread_; }

    Real payGearing() const { return payGearing_; }

    Real recNominal() const { return recNominal_; }

    const Currency& recCurrency() const { return recCurrency_; }

    const Schedule& recSchedule() const { return recSchedule_; }

    const ext::shared_ptr<IborIndex>& recIndex() const { return recIndex_; }

    Spread recSpread() const { return recSpread_; }

    Real recGearing() const { return recGearing_; }

    const StubIndexSelection& payStubIndexSelection() const { return payStubIndexSelection_; }

    const StubIndexSelection& recStubIndexSelection() const { return recStubIndexSelection_; }

    //@}

    //! \name Additional interface

    //@{

    Spread fairPaySpread() const {

        calculate();

        QL_REQUIRE(fairPaySpread_ != Null<Real>(), "Fair pay spread is not available");

        return fairPaySpread_;

    }

    Spread fairRecSpread() const {

        calculate();

        QL_REQUIRE(fairRecSpread_ != Null<Real>(), "Fair pay spread is not available");

        return fairRecSpread_;

    }

    //@}

  protected:

    //! \name Instrument interface

    //@{

    void setupExpired() const override;

    //@}

  private:

    void initialize();

    Real payNominal_;

    Currency payCurrency_;

    Schedule paySchedule_;

    ext::shared_ptr<IborIndex> payIndex_;

    Spread paySpread_;

    Real payGearing_;

    Real recNominal_;

    Currency recCurrency_;

    Schedule recSchedule_;

    ext::shared_ptr<IborIndex> recIndex_;

    Spread recSpread_;

    Real recGearing_;

    Integer payPaymentLag_;

    Integer recPaymentLag_;

    std::optional<bool> useIndexedCoupons_;

    bool paymentLagOnNotionalExchanges_;

    StubIndexSelection payStubIndexSelection_;

    StubIndexSelection recStubIndexSelection_;

    // OIS only

    bool payCompoundSpread_;

    Natural payLookbackDays_;

    bool payObservationShift_;

    Natural payLockoutDays_;

    RateAveraging::Type payAveragingMethod_;

    bool recCompoundSpread_;

    Natural recLookbackDays_;

    bool recObservationShift_;

    Natural recLockoutDays_;

    RateAveraging::Type recAveragingMethod_;

    bool telescopicValueDates_;

    mutable Spread fairPaySpread_;

    mutable Spread fairRecSpread_;

};

class ConstNotionalCrossCurrencyBasisSwap::arguments : public ConstNotionalCrossCurrencySwap::arguments {

  public:

    Spread paySpread;

    Spread recSpread;

    void validate() const override;

};

class ConstNotionalCrossCurrencyBasisSwap::results : public ConstNotionalCrossCurrencySwap::results {

  public:

    Spread fairPaySpread;

    Spread fairRecSpread;

    void reset() override;

};

}

#endif