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

#ifndef driftcalculators_h
#define driftcalculators_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 LMMDriftCalculatorWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    std::vector< std::vector<double> > mPseudo_square_root;
    std::vector<double> mDisplacements;
    std::vector<double> mTaus;
    long mNumeraire;
    long mAlive;

    string mReturnValue;

    string mError;

    LMMDriftCalculatorWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,std::vector< std::vector<double> > Pseudo_square_root
      ,std::vector<double> Displacements
      ,std::vector<double> Taus
      ,long Numeraire
      ,long Alive
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mPseudo_square_root(Pseudo_square_root)
      ,mDisplacements(Displacements)
      ,mTaus(Taus)
      ,mNumeraire(Numeraire)
      ,mAlive(Alive)
      {

      };

    //~LMMDriftCalculatorWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class LMMNormalDriftCalculatorWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    std::vector< std::vector<double> > mPseudo_square_root;
    std::vector<double> mTaus;
    long mNumeraire;
    long mAlive;

    string mReturnValue;

    string mError;

    LMMNormalDriftCalculatorWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,std::vector< std::vector<double> > Pseudo_square_root
      ,std::vector<double> Taus
      ,long Numeraire
      ,long Alive
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mPseudo_square_root(Pseudo_square_root)
      ,mTaus(Taus)
      ,mNumeraire(Numeraire)
      ,mAlive(Alive)
      {

      };

    //~LMMNormalDriftCalculatorWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class CMSMMDriftCalculatorWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    std::vector< std::vector<double> > mPseudo_square_root;
    std::vector<double> mDisplacements;
    std::vector<double> mTaus;
    long mNumeraire;
    long mAlive;
    long mSpanningFwds;

    string mReturnValue;

    string mError;

    CMSMMDriftCalculatorWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,std::vector< std::vector<double> > Pseudo_square_root
      ,std::vector<double> Displacements
      ,std::vector<double> Taus
      ,long Numeraire
      ,long Alive
      ,long SpanningFwds
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mPseudo_square_root(Pseudo_square_root)
      ,mDisplacements(Displacements)
      ,mTaus(Taus)
      ,mNumeraire(Numeraire)
      ,mAlive(Alive)
      ,mSpanningFwds(SpanningFwds)
      {

      };

    //~CMSMMDriftCalculatorWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class SMMDriftCalculatorWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    std::vector< std::vector<double> > mPseudo_square_root;
    std::vector<double> mDisplacements;
    std::vector<double> mTaus;
    long mNumeraire;
    long mAlive;

    string mReturnValue;

    string mError;

    SMMDriftCalculatorWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,std::vector< std::vector<double> > Pseudo_square_root
      ,std::vector<double> Displacements
      ,std::vector<double> Taus
      ,long Numeraire
      ,long Alive
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mPseudo_square_root(Pseudo_square_root)
      ,mDisplacements(Displacements)
      ,mTaus(Taus)
      ,mNumeraire(Numeraire)
      ,mAlive(Alive)
      {

      };

    //~SMMDriftCalculatorWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class LMMDriftCalculatorComputePlainWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mCurveState;

    std::vector<double> mReturnValue;

    string mError;

    LMMDriftCalculatorComputePlainWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string CurveState
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mCurveState(CurveState)
      {

      };

    //~LMMDriftCalculatorComputePlainWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class LMMDriftCalculatorComputeReducedWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mCurveState;

    std::vector<double> mReturnValue;

    string mError;

    LMMDriftCalculatorComputeReducedWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string CurveState
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mCurveState(CurveState)
      {

      };

    //~LMMDriftCalculatorComputeReducedWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class LMMDriftCalculatorComputeWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mCurveState;

    std::vector<double> mReturnValue;

    string mError;

    LMMDriftCalculatorComputeWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string CurveState
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mCurveState(CurveState)
      {

      };

    //~LMMDriftCalculatorComputeWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class LMMNormalDriftCalculatorComputePlainWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mCurveState;

    std::vector<double> mReturnValue;

    string mError;

    LMMNormalDriftCalculatorComputePlainWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string CurveState
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mCurveState(CurveState)
      {

      };

    //~LMMNormalDriftCalculatorComputePlainWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class LMMNormalDriftCalculatorComputeReducedWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mCurveState;

    std::vector<double> mReturnValue;

    string mError;

    LMMNormalDriftCalculatorComputeReducedWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string CurveState
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mCurveState(CurveState)
      {

      };

    //~LMMNormalDriftCalculatorComputeReducedWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class LMMNormalDriftCalculatorComputeWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mCurveState;

    std::vector<double> mReturnValue;

    string mError;

    LMMNormalDriftCalculatorComputeWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string CurveState
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mCurveState(CurveState)
      {

      };

    //~LMMNormalDriftCalculatorComputeWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class CMSMMDriftCalculatorComputeWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mCurveState;

    std::vector<double> mReturnValue;

    string mError;

    CMSMMDriftCalculatorComputeWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string CurveState
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mCurveState(CurveState)
      {

      };

    //~CMSMMDriftCalculatorComputeWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};

class SMMDriftCalculatorComputeWorker : public Nan::AsyncWorker {
  public:
    string mObjectID;
    string mCurveState;

    std::vector<double> mReturnValue;

    string mError;

    SMMDriftCalculatorComputeWorker(
      Nan::Callback *callback
      ,string ObjectID
      ,string CurveState
    ):
      Nan::AsyncWorker(callback)
      ,mObjectID(ObjectID)
      ,mCurveState(CurveState)
      {

      };

    //~SMMDriftCalculatorComputeWorker();

    //void Destroy();

    void Execute();

    void HandleOKCallback();

};
 
#endif