TSAInstrument.h

/*  ===================================================================
*
*                 T R A D I N G   S Y S T E M   A P I ™
*    Copyright © 1999 - 2014 by Peter Ritter ( TradingSystemAPI.com )
*                A L L   R I G H T S   R E S E R V E D
*
*     Consult your license regarding permissions and restrictions.
*             You may obtain a copy of the License at:
*     http://www.TradingSystemAPI.com/licenses/LICENSE-TSAPI-3.0.html
*
*  ====================================================================
*/

#ifndef TSA_INSTRUMENT__INCLUDED
#define TSA_INSTRUMENT__INCLUDED

#include <ostream>

#include "TSASupport.h"
#include "TSAMetrics.h"
#include "TSAMetrics2.h"
#include "TSATime.h"
#include "TSAOrderManager.h"
#include "TSAIntraday.h"
#include "TSAPriceBar.h"
#include "TSAStrategyPtr.h"
#include "TSALogs.h"
#include "TSAOrder.h"

namespace tsa {
    class strategy_delegate;
    namespace os {
        class path;
    }

    /*
    ** ====================================================
    ** >>>              class instrument                <<<
    ** ====================================================
    */

    class dll_export instrument : 
        public object, 
        public metrics_source {
        tsa_declare_testable;
        friend class tsa::strategy;
        friend class tsa::strategy_delegate;
    private:
        std::string m_sSymbol;
        std::string m_msg_symbol;
        std::string m_secType;
        std::string m_platform;
        std::string m_feed;
        std::string m_interval;
        std::string m_expiry;
        std::string m_expiry_yyyymm;
        double      m_strike;
        std::string m_right;
        std::string m_multiplier;
        std::string m_exchange;
        std::string m_contract_expiry;
        std::string m_primaryExchange; // actual (i.e. non-aggregate) exchange that the instrument trades on.
        std::string m_currency;
        bool        m_includeExpired;
        std::string m_secIdType; // CUSIP;SEDOL;ISIN;RIC
        std::string m_secId;
        size_t m_id;
    public:
        std::string         m_data_stream_name;
        std::string         m_data_store_name;
        in_stream           m_in_stream;
        in_stream_adaptor*  m_in_stream_adaptor_ptr;
    public:
        bool                m_is_initialized;
        bool                m_is_finalized;
        bar_log*            m_bar_log_ptr;
        strategy*           m_strategy_ptr;
        order_manager       m_order_mgr;
        strategy_delegate*  m_strat_base_ptr;
    private:
        bool                m_is_stand_alone;
        strategy_state_type m_strategy_state;
        size_t              m_nNumObj;
        bool                m_allow_zero_and_sub_zero_prices;
        size_t              m_bar_count;
        instrument_price_bar m_curr_price_bar;
        instrument_price_bar m_prev_bar_price_bar;
        date_time           m_last_price_bar_update_timestamp;
        date_time           m_bar_timestamp;
        date_time           m_prev_bar_timestamp;
        bool   m_is_scheduled_by_series;
        bool   m_is_time_master;
        bool   m_bar_duration_is_intraday;
        bool   m_undefined_values_allowed;
        bool   m_bMasterOHLCnotAvailable;
        double m_tick_size;
        double m_tick_value;
        bool   m_auto_round;
        bool   m_has_bid_ask;
        bool   m_use_bid_ask_for_sim_market_orders;
    public:
        //
        void use_bid_ask_for_sim_market_orders(bool flag);
        //
        bool use_bid_ask_for_sim_market_orders(void)const;
    private:
        mutable enum class chart_mkt_order_price_type{
            open, close, last, not_init
        }m_chart_mkt_order_price_type = chart_mkt_order_price_type::not_init;
        double m_chart_mkt_order_price;
    public:
        double chart_mkt_order_price(void)const;
    public:
        void set_next_bar(const date_time&, double o, double h, double l, double c, double v);
    public:
        struct daily_equity {
            date day;
            double strategy_equity;
            daily_equity(const date& _d, double _eq) : day(_d), strategy_equity(_eq) {}
        };
        std::vector<daily_equity> m_daily_equity;
    public:
        std::vector<component*> m_components;
    private:
        void InitMembers(const std::string& _name);
        std::list<order*> m_pre_submit_orders;
        void pre_submit_order(order*);
        void un_pre_submit_order(order*);
    public:
        void include_expired(bool _ie) { m_includeExpired = _ie; }
        bool include_expiry(void) const { return m_includeExpired; }
    private:
        void register_with_strategy();
    public:
        bool m_verbose_eval;
        std::ostream* m_verbose_stream_ptr;
    public:
        void set_ohlc(double, double, double, double);
        const order_manager* order_manager_ptr(void)const;
        strategy* strategy_ptr(void) const;
    public:
        const std::vector<trade_info>& closed_trades(void)const;

        const std::vector<trade_leg>& current_trade_legs(void)const;
    private:
        void set_strategy(strategy*);
        void initialize(void);
        bool fetch_ohlc_data(void);
        void finalize(void);
        size_t bar_count(void) const;
        void notify_increment_bar(void);
        bool EvaluateInterval(void);
        void EvaluateOrderQueueBacktesting(void);
    private:
        void Do_PRE_OPEN(void);
        void Do_OPEN(void);
        void Do_BAR(void);
        void Do_CLOSE(void);
        void Do_POST_CLOSE(void);
        void Do_POST_EVAL(void);
        void evaluate_order_queue_BAR(void);
        void evaluate_order_queue_POST_CLOSE(void);
    public:
        bool is_finalized(void) const;
    public: //for metrics_source interface
        virtual const date_time& metrics_source__begin_timestamp(void) const override;
        virtual const date_time& metrics_source__end_timestamp(void) const override;
        virtual bool is_contract(void) const override { return true; }
        virtual std::string metric_source_name(void) const override { return name(); }
    private:
        void verify_eval_not_started(void) const;
        void verify_is_finalized(void) const;
        void verify_reporting_enabled(void) const;
        strategy_state_type get_strategy_state(void) const;
        bool EvaluationHasStarted(void) const;
    public:
        const date_time& prev_interval_timestamp(void) const;
        const date_time& interval_timestamp(void) const;
        void set_strategy_time(const date_time&);
        void interval_timestamp(const date_time&);
        void is_strategy_scheduler(bool _b);
    public:
        const date_time& bar_timestamp(void) const;
    public:
        //===================================
        //===================================
        
        instrument(void);

        ~instrument(void);

        //=================
        //=================
    public:
        //===================================
        //===================================
        
        size_t id(void) const;

        bool is_platform_driven(void) const;

        bool is_live(void)const;

        //
        bool exception_on_backfill_orders(void)const;

        void name(const std::string& name);

        const std::string& name(void) const;

        //=================
        //=================
        
        // internal
        instrument& symbol_ex(const std::string&);
        
    public:
        //===================================
        //===================================

        void as_random_walk(duration bar_duration = duration::days(1));

        void connect(const std::string& stream_name, const std::string& database_name = "default");

        std::string stream_name(void) const;

        //IU
        std::string data_base_name(void) const;

        void connect(in_stream_adaptor& adaptor);

        date_time begin();

        date_time end();

        const series_core& operator()(size_t field_pos) const;

        const series_core& operator()(const std::string& field_name) const;

        size_t field_count(void) const;

        date_time record_timestamp(void) const;

        bool field_exists(const std::string& field_name) const;

        size_t field_index(const std::string& field_name) const;

        tsa::type_t field_type(const std::string& field_name) const;
        
        //=================
        //=================
        
        void verify_registered_with_strategy(void) const;
    public:
        //==============================
        //============================== 
        
        series<double> open;
        series<double> high;
        series<double> low;
        series<double> close;
        series<double> volume;
        series<double> bid;
        series<double> ask;
        series<double> bidsize;
        series<double> asksize;
        series<double> last;
        series<double> price;
        series<double> value;
        series<double> openint;
        //=================
        //=================
        
    public:
        //================================
        //================================

        void negative_prices_ok(bool neg_prices_ok);

        bool negative_prices_ok(void) const;

        double big_point(void) const;

        void tick(double min_tick, double tick_value, bool auto_round = true);

        double tick_size(void) const;

        double tick_value(void)const;

        double ticks(int64_t multiplier) const;

        void limit_fill_proviso(double proviso);

        double limit_fill_proviso(void) const;

        void slippage(double slip);

        double slippage(void) const;

        void commission(double comm);

        double commission(void) const;

        void cost_allocation(cost_alloc_type t);

        bool costs_allocated_per_unit(void) const;

        //=================
        //=================

        void SetInternalTradeLogDisabled(void); // deprecated
        bool GetInternalTradeLogDisabled(void) const;
        void SetAllocateSlippageAndCommissionPerUnit(bool _bFlag);    //obsolete
        //void ResetBigPointValue(double _dBigPointValue);
    public:
        //===================================
        //===================================

        std::string platform(void)const;

        instrument&  platform(const std::string& platform_name);

        std::string broker(void)const;

        instrument&  broker(const std::string& broker_name);

        std::string feed(void)const;

        std::string interval(void)const;

        instrument& define(const std::string& symbol, const std::string& exchange, const std::string& platform);

        instrument& symbol(const std::string& symb);

        const std::string& symbol(void) const;

        instrument&  expiry(const std::string& expiry);

        const std::string& expiry(void) const;

        const std::string& expiry_yyyymm(void) const;

        std::string instrument::type(void)const;

        instrument&  exchange(const std::string& exch);

        const std::string& exchange(void) const;

        instrument&  currency(const std::string& ccy);

        const std::string& currency(void)const;

        //=================
        //=================

    public:
        //=====================================
        //====================================
    private:
        order::time_in_force m_default_time_in_force = order::time_in_force::gtc;
    public:
        void default_time_in_force(order::time_in_force default_tif);
    public: //market orders

        order_ref buy(quantity_t quantity);

        // internal use
        order_ref buy(quantity_t quantity, double fixed_fill_price);

        order_ref buy_order(quantity_t quantity);

        order_ref sell(quantity_t quantity);

        // internal use
        order_ref sell(quantity_t quantity, double fixed_fill_price);

        order_ref sell_order(quantity_t quantity);

    public: //stop orders

        order_ref buy_stop(quantity_t quantity, double stop_price);

        order_ref buy_stop_order(quantity_t quantity, double stop_price);

        order_ref sell_stop(quantity_t quantity, double stop_price);

        order_ref sell_stop_order(quantity_t quantity, double stop_price);

    public: //stop limit orders

        order_ref buy_stop_limit(quantity_t quantity, double stop_price, double price_limit);

        order_ref buy_stop_limit_order(quantity_t quantity, double stop_price, double price_limit);

        order_ref sell_stop_limit(quantity_t quantity, double stop_price, double price_limit);

        order_ref sell_stop_limit_order(quantity_t quantity, double stop_price, double limit_price);

    public: //limit orders

        order_ref buy_limit(quantity_t quantity, double limit_price);

        order_ref buy_limit_order(quantity_t quantity, double limit_price);

        order_ref sell_limit(quantity_t quantity, double limit_price);

        order_ref sell_limit_order(quantity_t quantity, double limit_price);

        //=================
        //=================
    public:

        //===================================
        //===================================

        void cancel_all_orders(void);

        void cancel_order(identifier_t id);

        bool order_exists(identifier_t id) const;

        void get_orders(std::vector<order_ref>& v, bool active_only = true) const;

        bool has_active_orders(void)const;

        void get_active_orders(std::vector<order_ref>& v, order::type _ot, order::action) const;

        order_ref get_order(identifier_t id) const;

        order* get_order_ptr(identifier_t id) const;

        size_t order_count(void) const;

        size_t order_count_inclusive() const;

        //=================
        //=================
        
    public:// internal use
        void submit_order(order*);
        void init_order_properties(order*);
        void reset_expiry(identifier_t order_id, order::time_in_force tif);
        void reset_expiry(identifier_t order_id, const date_time& date_time);
        void reset_tag(identifier_t order_id, const std::string& tag);
        void reset_price(identifier_t order_id, double price, double aux_price = (-1.0));
        void reset_quantity(identifier_t order_id, quantity_t quantity);
    public:
        const std::vector<transaction>& get_bar_transactions(void) const;

    public:
        //===================================
        //===================================

        double net_profit(void) const;

        POSITION::state position_state() const;

        bool is_long(void) const;

        bool is_short(void) const;

        bool is_flat(void) const;

        quantity_t position_size(void) const;

        position_t position(void) const;
        //=================
        //=================
    public:
        //===========================
        //===========================

        size_t trade_leg_count(void) const;

        double trade_PL(void) const;

        size_t trade_bar_count(void) const;

        double trade_first_leg_entry_price(void) const;

        const date_time& trade_first_leg_entry_timestamp(void) const;

        quantity_t trade_max_position(void) const;

        double trade_most_favorable_price(void) const;

        // internal
        double trade_point_change_since_entry(void) const;

        //=================
        //=================
    public:
        //=============================
        //=============================

        // internal
        const transaction& get_most_recent_transaction(void) const;

        int64_t transact_count(void);

        int64_t transact_count(order::type order_type);

        int64_t unit_count(void);

        //=================
        //=================
         
        // internal
        int64_t filled_order_count(void);
    public:
        double  current_drawdown(void) const;
    public:
        bool    GetLastTradeIsOpen(trade_grouping t) const;
        bool    GetLastTradeWasOpen(void) const;
        double  GetMaxAccountBalance(double _start_balance) const;
        double  GetMinAccountBalance(double _start_balance) const;
        double  _GetCumulativePL_DDN_Log(void) const;
    public:
        void allow_null_values(bool flag);

        bool allow_null_values(void) const;
    public:
        const equity_metrics& get_equity_metrics(void) const;
        const order_manager& get_order_manager(void) const;
    public:
        order_log       m_order_log;
        bar_log         m_BarLog;
        trade_log       m_trade_log;
        drawdown_log    m_drawdown_log;
        transaction_log m_transact_log;
        int m_report_fp_precision;
        log_type_t m_enabled_logs;
    private:
        mutable std::vector<order_ref> m_tmp_orders;
    public:
        std::string transaction_info_string(void) const;
        std::string order_info_string(void) const;
    public:
        //================================
        //================================

        const metrics& get_metrics(void) const;

        virtual variant get_metric(perf_metric_type metric_type, trade_grouping grouping = all_trades) const;

        virtual variant metric(const std::string& metric_name, trade_grouping grouping = all_trades) const;

        //=================
        //=================
        // 
        // internal use
        virtual void daily_cash_flow(mem_table& mt) const;      
        void save_bar_report(const os::path& dir);
    public: //IU
        log_type_t GetLogType(void) const;
        fast::database* GetLogDBPtr(void) const;
        bool log_db_was_set(void) const;
        void write_reports(const os::path&);
        void log(log_type_t _eLogTypes, bool _bOverwrite);
        void print_order_report(std::ostream&, bool vertical, bool with_borders);
        void print_bar_report(std::ostream&, bool vertical, bool with_borders);
        void print_transaction_report(std::ostream&, bool vertical, bool with_borders);
        void print_trade_report(std::ostream&, bool vertical, bool with_borders);
        void print_drawdown_report(std::ostream&, bool vertical, bool with_borders);
    public: //IU
        void report_float_precision(size_t _precision);
        void save_transaction_report(const os::path& dir);
        void save_order_report(const os::path& dir);
        void save_trade_report(const os::path& dir);
        void save_drawdown_report(const os::path& dir);
        void save_performance_report(const os::path& path);
    protected:
        metrics  m_metrics;
        metrics2 m_metrics2;
        int64_t  transact_count_market(void);
        int64_t  transact_count_stop(void);
        int64_t  transact_count_limit(void);
        void populate_metrics_object(metrics2&);
    protected:
        double transact_price(double defaultPrice = 0.0);
        date_time transact_timestamp(void);
        quantity_t transact_size(void);
        int64_t transact_order_num(void);
        bool transact_had_slippage(void);
        std::string transact_order_type(void);
        std::string TransactExecInterval(void);
        bool transact_is_long(void);
        bool transact_is_short(void);
        std::string transact_order_message(void);
    };

}
#endif