/* 
  Copyright (C) 2016 -2017 Jerry Jin
*/

#ifndef marketmodels_h
#define marketmodels_h
#include <nan.h>
#include <string>
#include <queue>
#include <utility>

#include "../quantlibnode.hpp"

#include <oh/objecthandler.hpp>

using namespace node;
using namespace v8;
using namespace std;


class FlatVolWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    std::vector<double> mVolatilities;
    string mCorrelations;
    string mEvolutionDescription;
    long mFactors;
    std::vector<double> mInitialRates;
    std::vector<double> mDisplacements;

    string mReturnValue;

    string mError;

    FlatVolWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,std::vector<double> Volatilities
      ,string Correlations
      ,string EvolutionDescription
      ,long Factors
      ,std::vector<double> InitialRates
      ,std::vector<double> Displacements
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mVolatilities(Volatilities)
      ,mCorrelations(Correlations)
      ,mEvolutionDescription(EvolutionDescription)
      ,mFactors(Factors)
      ,mInitialRates(InitialRates)
      ,mDisplacements(Displacements)
      {

      };

    //~FlatVolWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class AbcdVolWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    double mA;
    double mB;
    double mC;
    double mD;
    std::vector<double> mKs;
    string mCorrelations;
    string mEvolutionDescription;
    long mFactors;
    std::vector<double> mInitialRates;
    std::vector<double> mDisplacements;

    string mReturnValue;

    string mError;

    AbcdVolWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,double A
      ,double B
      ,double C
      ,double D
      ,std::vector<double> Ks
      ,string Correlations
      ,string EvolutionDescription
      ,long Factors
      ,std::vector<double> InitialRates
      ,std::vector<double> Displacements
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mA(A)
      ,mB(B)
      ,mC(C)
      ,mD(D)
      ,mKs(Ks)
      ,mCorrelations(Correlations)
      ,mEvolutionDescription(EvolutionDescription)
      ,mFactors(Factors)
      ,mInitialRates(InitialRates)
      ,mDisplacements(Displacements)
      {

      };

    //~AbcdVolWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class PseudoRootFacadeWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mCalibrator;

    string mReturnValue;

    string mError;

    PseudoRootFacadeWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string Calibrator
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mCalibrator(Calibrator)
      {

      };

    //~PseudoRootFacadeWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class CotSwapToFwdAdapterWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mCoterminalModel;

    string mReturnValue;

    string mError;

    CotSwapToFwdAdapterWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string CoterminalModel
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mCoterminalModel(CoterminalModel)
      {

      };

    //~CotSwapToFwdAdapterWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class FwdPeriodAdapterWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mLargeModel;
    long mPeriod;
    long mOffset;
    std::vector<double> mDisplacements;

    string mReturnValue;

    string mError;

    FwdPeriodAdapterWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string LargeModel
      ,long Period
      ,long Offset
      ,std::vector<double> Displacements
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mLargeModel(LargeModel)
      ,mPeriod(Period)
      ,mOffset(Offset)
      ,mDisplacements(Displacements)
      {

      };

    //~FwdPeriodAdapterWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class FwdToCotSwapAdapterWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mForwardModel;

    string mReturnValue;

    string mError;

    FwdToCotSwapAdapterWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string ForwardModel
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mForwardModel(ForwardModel)
      {

      };

    //~FwdToCotSwapAdapterWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class FlatVolFactoryWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    double mLongTermCorr;
    double mBeta;
    std::vector<double> mTimes;
    std::vector<double> mVolatilities;
    ObjectHandler::property_t mYieldCurve;
    double mDisplacement;

    string mReturnValue;

    string mError;

    FlatVolFactoryWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,double LongTermCorr
      ,double Beta
      ,std::vector<double> Times
      ,std::vector<double> Volatilities
      ,ObjectHandler::property_t YieldCurve
      ,double Displacement
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mLongTermCorr(LongTermCorr)
      ,mBeta(Beta)
      ,mTimes(Times)
      ,mVolatilities(Volatilities)
      ,mYieldCurve(YieldCurve)
      ,mDisplacement(Displacement)
      {

      };

    //~FlatVolFactoryWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class MarketModelInitialRatesWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;

    std::vector<double> mReturnValue;

    string mError;

    MarketModelInitialRatesWorker(
      Nan::Callback *callback
      ,string ObjectID
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      {

      };

    //~MarketModelInitialRatesWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class MarketModelDisplacementsWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;

    std::vector<double> mReturnValue;

    string mError;

    MarketModelDisplacementsWorker(
      Nan::Callback *callback
      ,string ObjectID
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      {

      };

    //~MarketModelDisplacementsWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class MarketModelNumberOfRatesWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;

    long mReturnValue;

    string mError;

    MarketModelNumberOfRatesWorker(
      Nan::Callback *callback
      ,string ObjectID
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      {

      };

    //~MarketModelNumberOfRatesWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class MarketModelNumberOfFactorsWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;

    long mReturnValue;

    string mError;

    MarketModelNumberOfFactorsWorker(
      Nan::Callback *callback
      ,string ObjectID
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      {

      };

    //~MarketModelNumberOfFactorsWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class MarketModelNumberOfStepsWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;

    long mReturnValue;

    string mError;

    MarketModelNumberOfStepsWorker(
      Nan::Callback *callback
      ,string ObjectID
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      {

      };

    //~MarketModelNumberOfStepsWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class MarketModelPseudoRootWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    long mIndex;

    std::vector< std::vector<double> > mReturnValue;

    string mError;

    MarketModelPseudoRootWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,long Index
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mIndex(Index)
      {

      };

    //~MarketModelPseudoRootWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class MarketModelCovarianceWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    long mIndex;

    std::vector< std::vector<double> > mReturnValue;

    string mError;

    MarketModelCovarianceWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,long Index
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mIndex(Index)
      {

      };

    //~MarketModelCovarianceWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class MarketModelTotalCovarianceWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    long mIndex;

    std::vector< std::vector<double> > mReturnValue;

    string mError;

    MarketModelTotalCovarianceWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,long Index
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mIndex(Index)
      {

      };

    //~MarketModelTotalCovarianceWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class MarketModelTimeDependentVolatilityWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    long mIndex;

    std::vector<double> mReturnValue;

    string mError;

    MarketModelTimeDependentVolatilityWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,long Index
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mIndex(Index)
      {

      };

    //~MarketModelTimeDependentVolatilityWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class CoterminalSwapForwardJacobianWorker : public Nan::AsyncWorker {
  public:
    string mCurveState;

    std::vector< std::vector<double> > mReturnValue;

    string mError;

    CoterminalSwapForwardJacobianWorker(
      Nan::Callback *callback
      ,string CurveState
    ):
      Nan::AsyncWorker(callback)
      ,mCurveState(CurveState)
      {

      };

    //~CoterminalSwapForwardJacobianWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class CoterminalSwapZedMatrixWorker : public Nan::AsyncWorker {
  public:
    string mCurveState;
    double mDisplacement;

    std::vector< std::vector<double> > mReturnValue;

    string mError;

    CoterminalSwapZedMatrixWorker(
      Nan::Callback *callback
      ,string CurveState
      ,double Displacement
    ):
      Nan::AsyncWorker(callback)
      ,mCurveState(CurveState)
      ,mDisplacement(Displacement)
      {

      };

    //~CoterminalSwapZedMatrixWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class CoinitialSwapForwardJacobianWorker : public Nan::AsyncWorker {
  public:
    string mCurveState;

    std::vector< std::vector<double> > mReturnValue;

    string mError;

    CoinitialSwapForwardJacobianWorker(
      Nan::Callback *callback
      ,string CurveState
    ):
      Nan::AsyncWorker(callback)
      ,mCurveState(CurveState)
      {

      };

    //~CoinitialSwapForwardJacobianWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class CoinitialSwapZedMatrixWorker : public Nan::AsyncWorker {
  public:
    string mCurveState;
    double mDisplacement;

    std::vector< std::vector<double> > mReturnValue;

    string mError;

    CoinitialSwapZedMatrixWorker(
      Nan::Callback *callback
      ,string CurveState
      ,double Displacement
    ):
      Nan::AsyncWorker(callback)
      ,mCurveState(CurveState)
      ,mDisplacement(Displacement)
      {

      };

    //~CoinitialSwapZedMatrixWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class CmSwapForwardJacobianWorker : public Nan::AsyncWorker {
  public:
    string mCurveState;
    long mSpanningForwards;

    std::vector< std::vector<double> > mReturnValue;

    string mError;

    CmSwapForwardJacobianWorker(
      Nan::Callback *callback
      ,string CurveState
      ,long SpanningForwards
    ):
      Nan::AsyncWorker(callback)
      ,mCurveState(CurveState)
      ,mSpanningForwards(SpanningForwards)
      {

      };

    //~CmSwapForwardJacobianWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class CmSwapZedMatrixWorker : public Nan::AsyncWorker {
  public:
    string mCurveState;
    long mSpanningForwards;
    double mDisplacement;

    std::vector< std::vector<double> > mReturnValue;

    string mError;

    CmSwapZedMatrixWorker(
      Nan::Callback *callback
      ,string CurveState
      ,long SpanningForwards
      ,double Displacement
    ):
      Nan::AsyncWorker(callback)
      ,mCurveState(CurveState)
      ,mSpanningForwards(SpanningForwards)
      ,mDisplacement(Displacement)
      {

      };

    //~CmSwapZedMatrixWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class AnnuityWorker : public Nan::AsyncWorker {
  public:
    string mCurveState;
    long mStartIndex;
    long mEndIndex;
    long mNumeraireIndex;

    double mReturnValue;

    string mError;

    AnnuityWorker(
      Nan::Callback *callback
      ,string CurveState
      ,long StartIndex
      ,long EndIndex
      ,long NumeraireIndex
    ):
      Nan::AsyncWorker(callback)
      ,mCurveState(CurveState)
      ,mStartIndex(StartIndex)
      ,mEndIndex(EndIndex)
      ,mNumeraireIndex(NumeraireIndex)
      {

      };

    //~AnnuityWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class SwapDerivativeWorker : public Nan::AsyncWorker {
  public:
    string mCurveState;
    long mStartIndex;
    long mEndIndex;
    long mFwdRateIndex;

    double mReturnValue;

    string mError;

    SwapDerivativeWorker(
      Nan::Callback *callback
      ,string CurveState
      ,long StartIndex
      ,long EndIndex
      ,long FwdRateIndex
    ):
      Nan::AsyncWorker(callback)
      ,mCurveState(CurveState)
      ,mStartIndex(StartIndex)
      ,mEndIndex(EndIndex)
      ,mFwdRateIndex(FwdRateIndex)
      {

      };

    //~SwapDerivativeWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class RateVolDifferencesWorker : public Nan::AsyncWorker {
  public:
    string mMarketModel1;
    string mMarketModel2;

    std::vector<double> mReturnValue;

    string mError;

    RateVolDifferencesWorker(
      Nan::Callback *callback
      ,string MarketModel1
      ,string MarketModel2
    ):
      Nan::AsyncWorker(callback)
      ,mMarketModel1(MarketModel1)
      ,mMarketModel2(MarketModel2)
      {

      };

    //~RateVolDifferencesWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class RateInstVolDifferencesWorker : public Nan::AsyncWorker {
  public:
    string mMarketModel1;
    string mMarketModel2;
    long mIndex;

    std::vector<double> mReturnValue;

    string mError;

    RateInstVolDifferencesWorker(
      Nan::Callback *callback
      ,string MarketModel1
      ,string MarketModel2
      ,long Index
    ):
      Nan::AsyncWorker(callback)
      ,mMarketModel1(MarketModel1)
      ,mMarketModel2(MarketModel2)
      ,mIndex(Index)
      {

      };

    //~RateInstVolDifferencesWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};
 
#endif