context.hpp

#pragma once
 
#include "../strategy/event.hpp"
#include "../strategy/intent.hpp"
#include "../strategy/portfolio.hpp"
 
#include <algotradelib/core>
 
#if defined(ATL_HAS_EIGEN)
#include <algotradelib/analytics>
#endif
 
#include <chrono>
#include <cstddef>
#include <map>
#include <optional>
#include <string>
#include <unordered_map>
#include <utility>
#include <variant>
#include <vector>
 
namespace algotradelib {
namespace runner {
 
// The strategy types a runner speaks in, imported from `strategy`.
using strategy::BarEvent;
using strategy::CancelIntent;
using strategy::Fill;
using strategy::MarketPhase;
using strategy::OrderIntent;
using strategy::Portfolio;
using strategy::QuoteEvent;
using strategy::TargetPosition;

template <typename Broker>
using Instruction = std::variant<OrderIntent, TargetPosition, CancelIntent<Broker>>;

struct SeriesKey {
  InstrumentId instrument_;
  BarInterval interval_{BarInterval::ONE_DAY};

  friend bool operator<(const SeriesKey& lhs, const SeriesKey& rhs) {
    if (!(lhs.instrument_ == rhs.instrument_)) {
      return lhs.instrument_ < rhs.instrument_;
    }
    return lhs.interval_ < rhs.interval_;
  }
};

template <typename BrokerTag, typename CapsType>
class Context {
public:
  using Broker = BrokerTag;
  using caps = CapsType;

  Context(const Context&) = delete;
  Context& operator=(const Context&) = delete;
  Context(Context&&) = default;
  Context& operator=(Context&&) = default;

  class Log {
  public:
    void note(std::string_view message) {
      if (lines_.size() >= capacity_) {
        lines_.erase(lines_.begin());
      }
      lines_.emplace_back(message);
    }

    const std::vector<std::string>& lines() const noexcept { return lines_; }

    std::vector<std::string> take() {
      std::vector<std::string> taken;
      taken.swap(lines_);
      return taken;
    }
 
  private:
    // Bounded so a long session cannot grow it without limit.
    static constexpr std::size_t capacity_ = 4096;
    std::vector<std::string> lines_;
  };

  explicit Context(std::size_t series_capacity = 512) : series_capacity_(series_capacity) {}
 
  // --- What a strategy reads -------------------------------------------------------------

  std::chrono::system_clock::time_point now() const noexcept { return now_; }

  MarketPhase phase() const noexcept { return phase_; }

  const TradingCalendar& calendar() const noexcept { return calendar_; }

  const Portfolio<BrokerTag>& portfolio() const noexcept { return portfolio_; }

  std::optional<Instrument> instrument(const InstrumentId& id) const {
    const auto found = instruments_.find(id);
    if (found == instruments_.end()) {
      return std::nullopt;
    }
    return found->second;
  }

  std::optional<Decimal64> last_price(const InstrumentId& id) const {
    const auto found = prices_.find(id);
    if (found == prices_.end()) {
      return std::nullopt;
    }
    return found->second;
  }
 
#if defined(ATL_HAS_EIGEN)
  const analytics::SeriesBuffer* bars(
    const InstrumentId& id,
    BarInterval interval = BarInterval::ONE_DAY
  ) const {
    const auto found = series_.find(SeriesKey{id, interval});
    if (found == series_.end()) {
      return nullptr;
    }
    return &found->second;
  }
#endif

  Log& log() noexcept { return log_; }
 
  // --- What a strategy asks for ---------------------------------------------------------

  void submit(OrderIntent intent) { queued_.emplace_back(std::move(intent)); }

  void submit(TargetPosition target) { queued_.emplace_back(std::move(target)); }

  void cancel(const OrderRef<BrokerTag>& ref, std::string tag = {}) {
    queued_.emplace_back(CancelIntent<BrokerTag>{ref, std::move(tag)});
  }
 
  // --- What the runner uses ------------------------------------------------------------

  const std::vector<Instruction<BrokerTag>>& queued() const noexcept { return queued_; }

  std::vector<Instruction<BrokerTag>> drain() {
    std::vector<Instruction<BrokerTag>> taken;
    taken.swap(queued_);
    return taken;
  }

  void set_now(std::chrono::system_clock::time_point when) noexcept { now_ = when; }

  void set_phase(MarketPhase phase) noexcept { phase_ = phase; }

  void set_calendar(TradingCalendar calendar) { calendar_ = std::move(calendar); }

  void set_portfolio(Portfolio<BrokerTag> portfolio) { portfolio_ = std::move(portfolio); }

  void set_instrument(Instrument reference) {
    auto key = reference.id_;
    instruments_.insert_or_assign(std::move(key), std::move(reference));
  }

  void set_last_price(const InstrumentId& id, Decimal64 price) {
    prices_.insert_or_assign(id, std::move(price));
  }
 
#if defined(ATL_HAS_EIGEN)
  void record_bar(const BarEvent& event) {
    const SeriesKey key{event.instrument_, event.interval_};
    auto found = series_.find(key);
    if (found == series_.end()) {
      found = series_.emplace(key, analytics::SeriesBuffer(series_capacity_)).first;
    }
    found->second.push(event.bar_);
  }
#endif
 
private:
  // Hashes an instrument id for the two per-instrument tables below. Both are looked up by id and
  // never iterated, so their order is nobody's to observe.
  struct InstrumentHash {
    std::size_t operator()(const InstrumentId& id) const noexcept {
      std::size_t seed = std::hash<std::string>{}(id.symbol_);
      seed ^= static_cast<std::size_t>(id.country_) + 0x9e3779b97f4a7c15ULL + (seed << 6) + (seed >> 2);
      seed ^= static_cast<std::size_t>(id.venue_) + 0x9e3779b97f4a7c15ULL + (seed << 6) + (seed >> 2);
      return seed;
    }
  };
 
  std::size_t series_capacity_;
  std::chrono::system_clock::time_point now_{};
  MarketPhase phase_{MarketPhase::UNKNOWN};
  TradingCalendar calendar_;
  Portfolio<BrokerTag> portfolio_;
  std::unordered_map<InstrumentId, Instrument, InstrumentHash> instruments_;
  std::unordered_map<InstrumentId, Decimal64, InstrumentHash> prices_;
#if defined(ATL_HAS_EIGEN)
  std::map<SeriesKey, analytics::SeriesBuffer> series_;
#endif
  std::vector<Instruction<BrokerTag>> queued_;
  Log log_;
};
 
} // namespace runner
} // namespace algotradelib