execution.hpp

#pragma once
 
#include "../strategy/reconcile.hpp"
 
#include <algotradelib/core>
 
#include <array>
#include <chrono>
#include <string>
#include <type_traits>
#include <string_view>
#include <utility>
#include <vector>
 
namespace algotradelib {
namespace runner {

enum class SendOutcome {
  ACCEPTED,
  REJECTED,
  INDETERMINATE,
  UNAVAILABLE,
  REFUSED_LOCALLY,
};

inline constexpr std::array<SendOutcome, 5> all_send_outcomes{
  SendOutcome::ACCEPTED,
  SendOutcome::REJECTED,
  SendOutcome::INDETERMINATE,
  SendOutcome::UNAVAILABLE,
  SendOutcome::REFUSED_LOCALLY,
};

inline constexpr std::string_view send_outcome_name(SendOutcome outcome) noexcept {
  switch (outcome) {
    case SendOutcome::ACCEPTED:
      return "accepted";
    case SendOutcome::REJECTED:
      return "rejected";
    case SendOutcome::INDETERMINATE:
      return "indeterminate";
    case SendOutcome::UNAVAILABLE:
      return "unavailable";
    case SendOutcome::REFUSED_LOCALLY:
      return "refused_locally";
  }
  return "";
}
 
static_assert(
  lists_every_value(all_send_outcomes, [](SendOutcome outcome) { return !send_outcome_name(outcome).empty(); }),
  "all_send_outcomes must list every SendOutcome"
);

inline SendOutcome outcome_of(const BrokerError& error) {
  if (!error.reached_broker_) {
    // Checked first: a request that never went out settles the question whatever the category.
    return SendOutcome::REFUSED_LOCALLY;
  }
  switch (error.category_) {
    case ErrorCategory::TRANSPORT:
    case ErrorCategory::CANCELLED:
    case ErrorCategory::PROTOCOL:
      return SendOutcome::INDETERMINATE;
    case ErrorCategory::HTTP:
      return error.http_status_ >= 500 ? SendOutcome::INDETERMINATE : SendOutcome::REJECTED;
    case ErrorCategory::AUTHENTICATION:
    case ErrorCategory::RATE_LIMIT:
      return SendOutcome::REJECTED;
    case ErrorCategory::INVALID_ARGUMENT:
      // The broker was asked and refused (a client's own validation was caught above).
      return SendOutcome::REJECTED;
  }
  // An unrecognized category is treated as unknown, not refused.
  return SendOutcome::INDETERMINATE;
}

inline constexpr bool error_retries_when_unsent(ErrorCategory category) noexcept {
  switch (category) {
    case ErrorCategory::INVALID_ARGUMENT:
      return false;
    case ErrorCategory::CANCELLED:
    case ErrorCategory::TRANSPORT:
    case ErrorCategory::HTTP:
    case ErrorCategory::AUTHENTICATION:
    case ErrorCategory::RATE_LIMIT:
    case ErrorCategory::PROTOCOL:
      return true;
  }
  return false;
}

inline bool broker_unreachable(const BrokerError& error) noexcept {
  return !error.reached_broker_ && error_retries_when_unsent(error.category_);
}

inline bool broker_rate_limited(const BrokerError& error) noexcept {
  return error.reached_broker_ && error_category_is_rate_limit(error.category_);
}

inline constexpr bool send_outcome_reached_broker(SendOutcome outcome) noexcept {
  switch (outcome) {
    case SendOutcome::ACCEPTED:
    case SendOutcome::REJECTED:
    case SendOutcome::INDETERMINATE:
      return true;
    case SendOutcome::UNAVAILABLE:
    case SendOutcome::REFUSED_LOCALLY:
      return false;
  }
  return true;
}

inline constexpr bool send_outcome_is_local_failure(SendOutcome outcome) noexcept {
  switch (outcome) {
    case SendOutcome::UNAVAILABLE:
      return true;
    case SendOutcome::ACCEPTED:
    case SendOutcome::REJECTED:
    case SendOutcome::INDETERMINATE:
    case SendOutcome::REFUSED_LOCALLY:
      return false;
  }
  return true;
}
 
namespace runner_detail {
 
// Whether `Executor` can put an order in front of a real broker.
//
// Declared by the executor, because it is the executor that knows. It decides one thing: whether a
// runner built on it must have read the account before it places. That requirement has to hold for
// every live path, and there are more of those than the two binding factories --
// `doxygen/vignettes/binding-a-broker.md` shows a `Runner<..., SessionExecutor<Session>>` assembled
// by hand, and a rule installed only by the factories would hold for their callers and nobody else.
//
// **The default is `true`, and an executor opts *out*.** That is the opposite of how a detection
// trait beside it usually reads, and it is deliberate: the two directions fail differently. An unmarked
// executor assumed harmless is a consumer's own adapter -- one whose `place` forwards to `SessionExecutor` or
// straight to a broker client -- silently exempted from the rule, and it fails by sending a real order sized
// against an account nobody read. An unmarked executor assumed live is a test double that refuses until it is
// given a stamped portfolio or says `allow_absent_portfolio()`, and it fails by being noticed at once. Only
// one of those two is discoverable, so silence means live.
//
// `RecordingExecutor` and `backtest::QueueingExecutor` therefore say `false` explicitly: a dry run
// and a replay have no holdings inquiry that could have failed, and a replay stamps its own
// portfolio. `JournalingExecutor` forwards whatever it wraps, because recording an order does not
// change who receives it.
template <typename Executor, typename = void>
struct sends_to_a_broker : std::true_type {};
 
template <typename Executor>
struct sends_to_a_broker<Executor, std::void_t<decltype(Executor::reaches_a_broker)>>
  : std::bool_constant<Executor::reaches_a_broker> {};
 
} // namespace runner_detail

enum class WithheldReason {
  RECONCILE_REQUIRED,
  LOCAL_FAILURE,
  AWAITING_CONFIRMATION,
};

inline constexpr std::string_view withheld_reason_name(WithheldReason reason) noexcept {
  switch (reason) {
    case WithheldReason::RECONCILE_REQUIRED:
      return "reconcile_required";
    case WithheldReason::LOCAL_FAILURE:
      return "local_failure";
    case WithheldReason::AWAITING_CONFIRMATION:
      return "awaiting_confirmation";
  }
  return "unknown";
}

enum class WithheldPlanReason {
  PORTFOLIO_ABSENT,
  PORTFOLIO_STALE,
  PLACEMENT_HELD,
  PORTFOLIO_SUPERSEDED,
  AWAITING_CONFIRMATION,
};

inline constexpr std::string_view withheld_plan_reason_name(WithheldPlanReason reason) noexcept {
  switch (reason) {
    case WithheldPlanReason::PORTFOLIO_ABSENT:
      return "portfolio_absent";
    case WithheldPlanReason::PORTFOLIO_STALE:
      return "portfolio_stale";
    case WithheldPlanReason::PORTFOLIO_SUPERSEDED:
      return "portfolio_superseded";
    case WithheldPlanReason::PLACEMENT_HELD:
      return "placement_held";
    case WithheldPlanReason::AWAITING_CONFIRMATION:
      return "awaiting_confirmation";
  }
  return "unknown";
}

template <typename BrokerTag>
struct WithheldPlan {
  WithheldPlanReason reason_{WithheldPlanReason::PORTFOLIO_ABSENT};
  InstrumentId instrument_;
  std::string tag_;
  std::vector<OrderRef<BrokerTag>> not_canceled_;
  std::size_t not_placed_{0};
  std::string detail_;
};

enum class ObligationState {
  NONE,
  NAMED,
  UNNAMED,
  OPERATOR,
};

inline constexpr int obligation_weight(ObligationState state) noexcept {
  switch (state) {
    case ObligationState::NONE:
      return 0;
    case ObligationState::NAMED:
      return 1;
    case ObligationState::UNNAMED:
      return 2;
    case ObligationState::OPERATOR:
      return 3;
  }
  return 3;
}

inline constexpr bool obligation_is_unaccounted(ObligationState state) noexcept {
  switch (state) {
    case ObligationState::UNNAMED:
    case ObligationState::OPERATOR:
      return true;
    case ObligationState::NONE:
    case ObligationState::NAMED:
      return false;
  }
  return true;
}

inline constexpr bool obligation_needs_operator(ObligationState state) noexcept {
  switch (state) {
    case ObligationState::OPERATOR:
      return true;
    case ObligationState::NONE:
    case ObligationState::NAMED:
    case ObligationState::UNNAMED:
      return false;
  }
  return true;
}

struct Obligation {
  InstrumentId instrument_;
  std::string journal_id_;
  std::string order_id_;
  OrderSide side_{OrderSide::BUY};
  Decimal64 quantity_;
  std::chrono::system_clock::time_point sent_at_{};
  ObligationState state_{ObligationState::NAMED};
};

inline constexpr std::string_view obligation_state_name(ObligationState state) noexcept {
  switch (state) {
    case ObligationState::NONE:
      return "none";
    case ObligationState::NAMED:
      return "named";
    case ObligationState::UNNAMED:
      return "unnamed";
    case ObligationState::OPERATOR:
      return "operator";
  }
  return "unknown";
}

struct BrokerRefusal {
  std::string code_;
  std::string message_;
  InstrumentId instrument_;
  std::string tag_;
};

struct WithheldOrder {
  WithheldReason reason_{WithheldReason::RECONCILE_REQUIRED};
  strategy::PlannedOrder order_;
  std::string detail_;
};

class IndeterminacyLedger {
public:
  void mark(const InstrumentId& id, std::string detail) {
    for (auto& entry : pending_) {
      if (entry.instrument_ == id) {
        // Keep the first reason: the earliest unresolved instruction is the one in doubt.
        return;
      }
    }
    pending_.push_back(Entry{id, std::move(detail)});
  }

  bool requires_reconcile(const InstrumentId& id) const {
    for (const auto& entry : pending_) {
      if (entry.instrument_ == id) {
        return true;
      }
    }
    return false;
  }

  std::string_view detail(const InstrumentId& id) const {
    for (const auto& entry : pending_) {
      if (entry.instrument_ == id) {
        return entry.detail_;
      }
    }
    return {};
  }

  void resolve_after_reading_orders(const InstrumentId& id) {
    for (auto at = pending_.begin(); at != pending_.end(); ++at) {
      if (at->instrument_ == id) {
        pending_.erase(at);
        return;
      }
    }
  }

  std::vector<InstrumentId> pending() const {
    std::vector<InstrumentId> ids;
    ids.reserve(pending_.size());
    for (const auto& entry : pending_) {
      ids.push_back(entry.instrument_);
    }
    return ids;
  }

  bool empty() const noexcept { return pending_.empty(); }
 
private:
  struct Entry {
    InstrumentId instrument_;
    std::string detail_;
  };
 
  std::vector<Entry> pending_;
};

template <typename BrokerTag>
class RecordingExecutor {
public:

  static constexpr bool reaches_a_broker = false;
  SendOutcome place(const strategy::PlannedOrder& order) {
    placed_.push_back(order);
    return SendOutcome::ACCEPTED;
  }

  SendOutcome cancel(const WorkingOrder<BrokerTag>& working) {
    canceled_.push_back(working.ref_);
    return SendOutcome::ACCEPTED;
  }

  const std::vector<strategy::PlannedOrder>& placed() const noexcept { return placed_; }

  const std::vector<OrderRef<BrokerTag>>& canceled() const noexcept { return canceled_; }
 
private:
  std::vector<strategy::PlannedOrder> placed_;
  std::vector<OrderRef<BrokerTag>> canceled_;
};
 
} // namespace runner
} // namespace algotradelib