sgContext.h

#ifndef SGCONTEXT_H
#define SGCONTEXT_H

#include "sgCommon.h"
#include <sharedSingleOrder.h>
#include <sgApiParameters.h>
#include <sgDebugLogDefines.h>
#include <baseCommands.h>

namespace API2
{


  class SGContextImpl;

  class SGContext
  {

  public:

    virtual ~SGContext();



    SGContext(StrategyParameters *params, const std::string sgName);


    /***********************************************************/
    /************************ Factory Calls ********************/
    /***********************************************************/


    COMMON::Instrument *createNewInstrument(UNSIGNED_LONG symbolId,bool regMktData, bool useSnapShot=false, bool useOhlc=true);

    COMMON::Instrument * createNewInstrument(const std::string &instrumentName, bool regMktData=false, bool useSnapShot=true, bool useOhlc=false);

    SingleOrder * createNewOrder(
                        COMMON::Instrument *instrument,
                        const UNSIGNED_LONG &qty=0,
                        const UNSIGNED_LONG &discQty=0,
                        const DATA_TYPES::OrderMode &mode=CONSTANTS::CMD_OrderMode_BUY,
                        const DATA_TYPES::OrderType &type = CONSTANTS::CMD_OrderType_LIMIT,
                        const DATA_TYPES::OrderValidity &validity = CONSTANTS::CMD_OrderValidity_DAY,
                        const DATA_TYPES::ProductType &product = CONSTANTS::CMD_ProductType_DELIVERY,
                        const UNSIGNED_LONG &price=0,
                        const UNSIGNED_LONG &stopPrice=0
        );

    COMMON::OrderId * createNewOrderId(
            COMMON::Instrument *instrument,
            const API2::AccountDetail &accountDetail,
            const DATA_TYPES::OrderMode &mode
            );

    /***********************************************************/
    /************************ Request Calls ********************/
    /***********************************************************/

    bool reqNewSingleOrder(DATA_TYPES::RiskStatus &riskStatus,
                      COMMON::Instrument *instrument,
                      SingleOrder *&order,
                      COMMON::OrderId *orderId);


    bool reqReplaceOrder(DATA_TYPES::RiskStatus &riskStatus,
                          COMMON::Instrument *instrument,
                          SingleOrder *&order,
                          COMMON::OrderId *orderId);

    bool reqCancelOrder(DATA_TYPES::RiskStatus &riskStatus, COMMON::OrderId *orderId);


    void reqCancelAllOrders();


    virtual void reqTerminateSquareOffStrategy();

    virtual void reqTerminateStrategy(bool reqCancelAllOrders=true);



    void *reqStartAlgo(bool marketDataEventRequired, bool tradeTicksEventRequired);

    void *reqStartOHLCAlgo();

    bool reqProcessTradeTicks(bool &error, SYMBOL_ID symbolId);

    void reqRemoveInstrument(COMMON::Instrument *instrument);

    void reqRemoveAllInstruments();

    bool reqUpdateMarketData();

    bool reqUpdateMarketData(UNSIGNED_LONG symbolId);

    void reqAddStrategyComment(DATA_TYPES::StrategyComment com);

    void reqSendStrategyResponse(
        DATA_TYPES::ResponseType responseType,
        DATA_TYPES::RiskStatus riskStatus,
        DATA_TYPES::StrategyComment strategyComment = CONSTANTS::RSP_StrategyComment_MAX
        );

    void reqExitStrategy();

    /***********************************************************/
    /************************ Query Calls ********************/
    /***********************************************************/


    virtual bool reqQryTestSegment(
        const DATA_TYPES::ExchangeId &exch,
        const DATA_TYPES::SecurityType &securityType = CONSTANTS::CMD_SecurityType_MAX
        );


    int reqQryClientID();

    StrategyParameters *reqQryStrategyParams();

    COMMON::MktData *reqQryUpdateMarketData(SYMBOL_ID symbolId);

    COMMON::MktData *reqQryMarketData(SYMBOL_ID symbolId);


    COMMON::OhlcQuote *reqQryOHLCQuote(bool &error, SYMBOL_ID symbolId);


    SIGNED_LONG reqQryNetMarkToMarkPL();

    SIGNED_LONG reqQryNetBookedPL();

    DATA_TYPES::SYMBOL_ID reqQrySymbolID(std::string instrumentName);



    std::list<API2::COMMON::Instrument *> reqQryInstrumentList(UNSIGNED_LONG symbolId);


    API2::SingleOrder* reqQryOrder(long clOrderId);


    API2::DATA_TYPES::STRATEGY_ID reqQryStrategyId();



    DebugLog *reqQryDebugLog();

    UNSIGNED_LONG reqQryPendingQty(COMMON::Instrument* instrument,
                                DATA_TYPES::OrderMode mode);

    DATA_TYPES::QTY reqQryPendingQty(COMMON::OrderId *orderId);

    DATA_TYPES::CLORDER_ID reqQryClientOrderId(COMMON::OrderId *orderId);

    DATA_TYPES::OrderStatus reqQryOrderStatus(COMMON::OrderId *orderId);

    DATA_TYPES::String reqQryExchangeOrderId(COMMON::OrderId *orderId);

    /***********************************************************/
    /************************ Get Dump String Calls ********************/
    /***********************************************************/


    DATA_TYPES::String getStrConfirmation(const OrderConfirmation &confirmation);

    DATA_TYPES::String getStrSingleOrder(SingleOrder *order);

    DATA_TYPES::String getStrOrderId(const COMMON::OrderId *orderId);


    /***********************************************************/
    /************************ Command Call-Backs ********************/
    /***********************************************************/


    virtual void onCMDAdminCommand(DATA_TYPES::CommandCategory command){}


    /***NOTE ** Disconnection type to be created inside Data_TYPES and constants to be added */
    virtual void onCMDDisconnection(const DATA_TYPES::CommandCategory &command);

    virtual void onCMDModifyStrategy(AbstractUserParams *newParams) =0;

    virtual void onCMDTerminateStartegy();

    virtual void onCMDTerminateSqOffStrategy();

    virtual void onCMDPauseStartegy();

    virtual void onCMDRunStrategy();

    virtual void onCMDInit(){}

    /***********************************************************/
    /************************ Event Call-Backs ********************/
    /***********************************************************/


    virtual void onDefaultEvent();

    virtual void onMarketDataEvent(UNSIGNED_LONG symbolId);

    virtual void onOhlcTimeOutEvent();

    virtual void onTradeTickEvent(COMMON::TradeTick tradeTick);


    virtual void onProcessOrderConfirmation(OrderConfirmation &confirmation){}


    virtual void onConfirmed(OrderConfirmation &confirmation, COMMON::OrderId *orderId){}

    virtual void onReplaceRejected(OrderConfirmation &confirmation, COMMON::OrderId *orderId){}

    virtual void onCanceled(OrderConfirmation &confirmation, COMMON::OrderId *orderId){}

    virtual void onCancelRejected(OrderConfirmation &confirmation, COMMON::OrderId *orderId){}

    virtual void onReplaced(OrderConfirmation &confirmation, COMMON::OrderId *orderId){}

    virtual void onNewReject(OrderConfirmation &confirmation, COMMON::OrderId *orderId){}

    virtual void onIOCCanceled(OrderConfirmation &Confirmation, COMMON::OrderId *orderId){}

    virtual void onFilled(OrderConfirmation &confirmation, COMMON::OrderId *orderId){}

    virtual void onPartialFill(OrderConfirmation &confirmation, COMMON::OrderId *orderId){}

    virtual void onMarketToLimit(API2::OrderConfirmation &confirmation, API2::COMMON::OrderId *orderId){}

    virtual void onFrozen(API2::OrderConfirmation &confirmation, API2::COMMON::OrderId *orderId){}


  private:

    SGContext();

    SGContext( const SGContext& other ); // non construction-copyable

    SGContext& operator=( const SGContext& ); // non copyable

    SGContextImpl *pimpl;


  };

} //namespace  API2
#endif // SGCONTEXT_H