traits.hpp

#pragma once

#define ATL_BROKER_ADAPTER_PRESENT 1
 
#include "./client.hpp"
 
#include "../../core/broker_session.hpp"
#include "../../core/broker_traits.hpp"
 
#include <boost/asio/associated_executor.hpp>
#include <boost/asio/dispatch.hpp>
#include <boost/asio/execution/outstanding_work.hpp>
#include <boost/asio/post.hpp>
#include <boost/asio/prefer.hpp>
 
#include <optional>
#include <string>
#include <utility>
 
namespace algotradelib {
 
namespace kiwoom {

struct Broker {
  static constexpr std::string_view name = "kiwoom";
};
 
namespace traits_detail {

using Ref = OrderRef<kiwoom::Broker>;

struct Normalizers {
  static constexpr bool has_depth = true;

  static constexpr bool has_price_limits = true;

  static constexpr bool has_trade_prints = true;

  static constexpr bool has_batch_prices = false;

  static constexpr bool has_buying_power = true;

  static constexpr bool has_buying_power_quantity = true;

  static constexpr SellableSource sellable_source = SellableSource::NONE;

  static constexpr bool has_commission_schedule = false;

  static constexpr bool has_reference_data = true;

  static constexpr bool has_batch_reference_data = false;

  static constexpr bool has_calendar = false;

  static constexpr bool has_calendar_range = false;

  static constexpr bool has_calendar_sessions = false;

  static std::optional<BrokerError> validate_calendar(Country country, std::optional<Date> from) {
    static_cast<void>(country);
    static_cast<void>(from);
    BrokerError error;
    error.category_ = ErrorCategory::INVALID_ARGUMENT;
    error.reached_broker_ = false;
    error.broker_code_ = "calendar_unsupported";
    error.message_ = "Kiwoom publishes no trading calendar";
    return error;
  }

  static constexpr bool supports_interval(BarInterval interval) {
    return kiwoom::chart_api_id(interval) != nullptr && kiwoom::chart_rows_field(interval) != nullptr;
  }

  static std::optional<BrokerError> validate_bars(const BarQuery& query) {
    return kiwoom::unsupported_bar_interval(query.interval_);
  }

  static Result<HoldingsSnapshot> refuse_holdings() {
    BrokerError error;
    error.category_ = ErrorCategory::INVALID_ARGUMENT;
    error.reached_broker_ = false;
    error.broker_code_ = "holdings_scope_unestablished";
    error.message_ =
      "Kiwoom's balance inquiry names one venue (kt00018 dmst_stex_tp: KRX or NXT) and publishes no "
      "all-venue value, and whether that filters the positions or only values them is not stated. "
      "This library will not present one venue's answer as the account's holdings unless you say "
      "that is what it is: set KiwoomConfig::holdings_position_scope_ to "
      "KiwoomPositionScope::VALUATION_ONLY to assert it, and "
      "KiwoomConfig::holdings_sellable_scope_ separately for trde_able_qty. Until then read the rows "
      "through session.client().holdings(). Both assertions are unverified; see KiwoomConfig's "
      "documentation";
    return Result<HoldingsSnapshot>(std::move(error));
  }

  static Ref make_ref(const KiwoomOrderRef& order) {
    Ref ref;
    ref.primary_ = order.order_number_;
    ref.secondary_ = order.symbol_;
    return ref;
  }

  static KiwoomOrderRef from_ref(const Ref& ref) {
    KiwoomOrderRef order;
    order.order_number_ = ref.primary_;
    order.symbol_ = ref.secondary_;
    return order;
  }

  static std::optional<BrokerError> validate_place(const OrderRequest& order) {
    // **The holdings refusal is deliberately not repeated here**, although this is the port's
    // pre-flight. It lives in `KiwoomClient::validate_order`, which every placement reaches --
    // including this port's, because `place` calls the client immediately after this returns and
    // the client refuses before any I/O. Checking it here as well would only change *which* message
    // a caller gets: this function does not validate the order's venue, price or shape, so it would
    // report the holdings gap for an order that is also malformed, burying the mistake the caller
    // can actually fix. See `kiwoom::unestablished_holdings_scope`.
    return kiwoom::unsupported_client_order_id(order);
  }

  static Result<PlacedOrder<kiwoom::Broker>> normalize_place(Result<KiwoomOrderAck> raw) {
    if (!raw) {
      return Result<PlacedOrder<kiwoom::Broker>>(std::move(raw.error()));
    }
    PlacedOrder<kiwoom::Broker> placed;
    placed.ack_ = std::move(raw.value().ack_);
    placed.ref_ = make_ref(raw.value().order_);
    return Result<PlacedOrder<kiwoom::Broker>>(std::move(placed));
  }

  static Result<WorkingOrders<kiwoom::Broker>> normalize_working_orders(
    Result<KiwoomOpenOrderPage> raw
  ) {
    if (!raw) {
      return Result<WorkingOrders<kiwoom::Broker>>(std::move(raw.error()));
    }
    WorkingOrders<kiwoom::Broker> orders;
    orders.received_at_ = raw.value().received_at_;
    orders.orders_.reserve(raw.value().orders_.size());
    for (auto& open_order : raw.value().orders_) {
      WorkingOrder<kiwoom::Broker> working;
      working.order_ = std::move(open_order.order_);
      working.ref_ = make_ref(open_order.order_ref_);
      working.amendable_quantity_ = open_order.amendable_quantity_;
      orders.orders_.push_back(std::move(working));
    }
    return Result<WorkingOrders<kiwoom::Broker>>(std::move(orders));
  }

  static Result<KiwoomAmendment> to_amendment(
    const Ref& ref,
    const AmendInstruction& instruction,
    bool cancel
  ) {
    BrokerError error;
    error.category_ = ErrorCategory::INVALID_ARGUMENT;
    error.reached_broker_ = false;
 
    if (!instruction.all_remaining_ && !instruction.quantity_) {
      error.broker_code_ = "quantity_required";
      error.message_ =
        "a Kiwoom modification or cancellation affects a stated quantity; set all_remaining_ to "
        "act on everything still resting, or build the instruction with cancel_all()";
      return Result<KiwoomAmendment>(std::move(error));
    }
    if (auto refusal = refuse_shape_change(instruction, cancel)) {
      return Result<KiwoomAmendment>(std::move(*refusal));
    }
 
    KiwoomAmendment amendment;
    amendment.order_ = from_ref(ref);
    amendment.venue_ = instruction.venue_;
    // Kiwoom's own "everything still resting", which it evaluates when it processes the
    // instruction rather than when the caller read the listing.
    amendment.quantity_ =
      instruction.all_remaining_ ? Decimal64() : *instruction.quantity_;
    if (!cancel) {
      // The basis is known here and nowhere after: `kt10002` carries no `trde_tp`, so this is the
      // last point that can tell a trigger the order wants from one it would silently lose.
      const auto trigger = amended_trigger_price(instruction);
      if (auto invalid = kiwoom::invalid_trigger(instruction.shape_.type_, trigger)) {
        return Result<KiwoomAmendment>(std::move(*invalid));
      }
      amendment.price_ = instruction.shape_.price_;
      amendment.condition_price_ = trigger;
    }
    // **Never on a cancellation.** `kt10003` has no trigger field and the client refuses a
    // cancellation carrying one; `cancel_all` restates the resting trigger, so copying it here would
    // make every stop order impossible to withdraw through the port.
    return Result<KiwoomAmendment>(std::move(amendment));
  }

  static std::optional<BrokerError> refuse_shape_change(
    const AmendInstruction& instruction,
    bool cancel
  ) {
    BrokerError error;
    error.category_ = ErrorCategory::INVALID_ARGUMENT;
    error.reached_broker_ = false;
    error.broker_code_ = "shape_change_unsupported";
 
    const auto refuse = [&error, cancel](const char* what) {
      error.message_ = cancel ?
        std::string("Kiwoom's cancellation carries a quantity and nothing else, so it cannot "
                    "change an order's ") + what + " on the way out" :
        std::string("Kiwoom's amendment endpoints carry a quantity and a price only, so they "
                    "cannot change an order's ") + what +
          "; cancel the order and place a new one instead";
      return error;
    };
 
    // An unset field means "leave it as it is", so it is never a change. A set field is a change
    // only when it differs from what the order already is -- and a set field with no resting shape
    // to compare against cannot be shown to be a restatement, so it is refused rather than assumed
    // harmless.
    const auto differs = [](auto stated, auto current) {
      return stated.has_value() && (!current.has_value() || *stated != *current);
    };
 
    if (cancel) {
      // **A cancellation transmits a quantity and nothing else**, so every other stated field is
      // one Kiwoom cannot act on. The price and the trigger are refused because acting on them is
      // what a caller would expect; these three are refused for the same reason and it is not a
      // lesser one -- reporting acceptance for a stated change that never reached the broker is
      // the defect, whatever the field.
      //
      // `cancel_all()` and `cancel_quantity()` copy the resting order's whole shape into both
      // `shape_` and `resting_`, so every comparison below sees a restatement and the ordinary
      // withdrawal path is unaffected.
      const bool restates_price = instruction.resting_ &&
        instruction.resting_->price_ == instruction.shape_.price_;
      if (instruction.shape_.price_ && !restates_price) {
        error.broker_code_ = "price_on_cancellation";
        error.message_ =
          "Kiwoom's cancellation carries a quantity and no price, so it cannot reprice an order on "
          "the way out; cancel it and place a new one instead";
        return error;
      }
      // The same rule as the price: a restatement of the resting trigger -- which is what
      // `cancel_all` writes -- is the ordinary withdrawal, and only a stated *change* is refused.
      const bool restates_trigger = instruction.resting_ &&
        instruction.resting_->trigger_price_ == instruction.shape_.trigger_price_;
      if (instruction.shape_.trigger_price_ && !restates_trigger) {
        error.broker_code_ = "trigger_on_cancellation";
        error.message_ =
          "Kiwoom's cancellation carries a quantity and no trigger price, so it cannot move an "
          "order's stop on the way out; cancel it and place a new one instead";
        return error;
      }
    } else if (!instruction.resting_) {
      // **A modification with no resting shape is refused, and that is the conservative
      // direction.** `OrderShape::type_` is a plain value defaulting to `LIMIT`, so this adapter
      // cannot tell a caller who *means* `LIMIT` from one who left it alone -- and if the resting
      // order is a best-limit order, accepting the instruction would send a price and leave the
      // basis where it was, reporting success for a change that did not happen. KIS refuses the
      // same case for the same reason, as `incomplete_shape`.
      error.broker_code_ = "incomplete_shape";
      error.message_ =
        "Kiwoom's modification cannot change an order's price basis, validity condition or session, "
        "and without the order's current shape this adapter cannot tell a restatement from a "
        "change; build the instruction with reprice() or replace_with(), which take it from the "
        "resting order";
      return error;
    }
 
    const auto resting_condition = instruction.resting_ ?
      instruction.resting_->time_in_force_ :
      std::optional<TimeInForce>();
    const auto resting_session = instruction.resting_ ?
      instruction.resting_->session_ :
      std::optional<OrderSession>();
    if (differs(instruction.shape_.time_in_force_, resting_condition)) {
      return refuse("validity condition");
    }
    if (differs(instruction.shape_.session_, resting_session)) {
      return refuse("session");
    }
    // `OrderShape::type_` is a plain value rather than an optional, so "left alone" and "stated
    // `LIMIT`" are the same bytes and the comparison has to be made in two steps.
    if (instruction.resting_) {
      if (instruction.shape_.type_ != instruction.resting_->type_) {
        return refuse("price basis");
      }
    } else if (instruction.shape_.type_ != OrderShape().type_) {
      // **With no resting shape, a value that differs from the default is still a stated change.**
      // Only the default is ambiguous; `MARKET` on a cancellation is a caller saying something, and
      // `kt10003` transmits no basis, so accepting it would report acceptance for a change the
      // broker never saw. Compared against `OrderShape`'s own default rather than a literal, so the
      // two cannot drift apart.
      return refuse("price basis");
    }
    return std::nullopt;
  }

  static Result<KiwoomAmendment> to_replacement(
    const Ref& ref,
    const AmendInstruction& instruction
  ) {
    return to_amendment(ref, instruction, false);
  }

  static Result<KiwoomAmendment> to_cancellation(
    const Ref& ref,
    const AmendInstruction& instruction
  ) {
    return to_amendment(ref, instruction, true);
  }

  static Result<KiwoomHistoryQuery> to_history_query(
    const KiwoomAccount&,
    const OrderHistoryQuery& query
  ) {
    BrokerError error;
    error.category_ = ErrorCategory::INVALID_ARGUMENT;
    error.reached_broker_ = false;
    if (!query.from_) {
      error.broker_code_ = "date_required";
      error.message_ = "Kiwoom's order-history inquiry lists one calendar date, which must be given";
      return Result<KiwoomHistoryQuery>(std::move(error));
    }
    if (query.to_ && !(query.to_->year_ == query.from_->year_ &&
                       query.to_->month_ == query.from_->month_ &&
                       query.to_->day_ == query.from_->day_)) {
      error.broker_code_ = "single_date_only";
      error.message_ =
        "Kiwoom's order-history inquiry lists one calendar date; ask for each date separately "
        "rather than for a range";
      return Result<KiwoomHistoryQuery>(std::move(error));
    }
    if (query.cursor_) {
      error.broker_code_ = "cursor_unsupported";
      error.message_ = "Kiwoom order history pages internally and exposes no cursor";
      return Result<KiwoomHistoryQuery>(std::move(error));
    }
    if (query.limit_) {
      error.broker_code_ = "limit_unsupported";
      error.message_ = "Kiwoom order history documents no row limit and cannot honor one";
      return Result<KiwoomHistoryQuery>(std::move(error));
    }
    KiwoomHistoryQuery converted;
    converted.date_ = *query.from_;
    converted.symbol_ = query.symbol_ ? *query.symbol_ : std::string();
    return Result<KiwoomHistoryQuery>(std::move(converted));
  }

  static KiwoomAccount selector_of(const KiwoomAccountInfo&) { return KiwoomAccount{}; }

  static std::string display_of(const KiwoomAccountInfo& account) {
    return account.account_number_;
  }

  static std::string type_of(const KiwoomAccountInfo&) { return {}; }
};

struct Capabilities {
  static constexpr bool has_account_discovery = true;

  static constexpr bool has_client_order_id = false;

  static constexpr bool has_trigger_price = true;

  static constexpr bool data_only = false;

  static constexpr bool has_working_orders = true;

  static constexpr bool has_amendable_quantity = true;

  static constexpr bool working_orders_state_terminal = false;

  static constexpr bool has_order_by_id = false;

  static constexpr bool has_partial_cancel = true;

  static constexpr bool history_requires_range = false;

  static constexpr bool has_history_cursor = false;

  static constexpr bool has_history_limit = false;

  static constexpr bool has_history_symbol_filter = true;
};
 
} // namespace traits_detail
} // namespace kiwoom

inline constexpr Venue kiwoom_route(Venue asked) noexcept { return kiwoom::kiwoom_effective_route(asked); }

template <>
struct BrokerTraits<kiwoom::KiwoomClient>
: kiwoom::traits_detail::Normalizers, kiwoom::traits_detail::Capabilities {
  static constexpr Venue effective_route(Venue asked) noexcept { return kiwoom_route(asked); }

  using Client = kiwoom::KiwoomClient;

  using Config = kiwoom::KiwoomConfig;

  using Account = kiwoom::KiwoomAccount;

  using AccountListItem = kiwoom::KiwoomAccountInfo;

  using BrokerTag = kiwoom::Broker;

  using PlaceAck = kiwoom::KiwoomOrderAck;

  using Amendment = kiwoom::KiwoomAmendment;

  using HistoryQuery = kiwoom::KiwoomHistoryQuery;

  using WorkingOrdersResult = kiwoom::KiwoomOpenOrderPage;

  static constexpr std::string_view name = kiwoom::Broker::name;

  static constexpr bool blocking = false;

  static const network::RateLimitStats* rate_limit_stats(const Client& client) {
    return client.rate_limit_stats();
  }

  template <typename Token>
  static auto quote(Client& client, InstrumentId instrument, Token&& token) {
    return client.async_quote(std::move(instrument), std::forward<Token>(token));
  }

  template <typename Token>
  static auto price_limits(Client& client, InstrumentId instrument, Token&& token) {
    return client.async_price_limits(std::move(instrument), std::forward<Token>(token));
  }

  template <typename Token>
  static auto trades(Client& client, InstrumentId instrument, int count, Token&& token) {
    return client.async_trades(std::move(instrument), count, std::forward<Token>(token));
  }

  template <typename Token>
  static auto depth(Client& client, InstrumentId instrument, Token&& token) {
    return client.async_depth(std::move(instrument), std::forward<Token>(token));
  }

  template <typename Token>
  static auto bars(Client& client, BarQuery query, Token&& token) {
    return client.async_bars(std::move(query), std::forward<Token>(token));
  }

  template <typename Token>
  static auto instrument(Client& client, InstrumentId subject, Token&& token) {
    return client.async_instrument(std::move(subject), std::forward<Token>(token));
  }

  template <typename Token>
  static auto accounts(Client& client, Token&& token) {
    return client.async_accounts(std::forward<Token>(token));
  }

  template <typename Token>
  static auto buying_power(
    Client& client,
    const Account& account,
    Currency currency,
    Token&& token
  ) {
    return client.async_buying_power(currency, account, std::forward<Token>(token));
  }

  template <typename Token>
  static auto holdings(Client& client, const Account& account, Token&& token) {
    if (!kiwoom::kiwoom_position_scope_asserted(client.config().holdings_position_scope_)) {
      static_cast<void>(account);
      return net::async_initiate<Token, void(Result<HoldingsSnapshot>)>(
        [strand = client.get_executor()](auto&& handler) mutable {
          auto work = net::prefer(
            net::get_associated_executor(handler), net::execution::outstanding_work.tracked
          );
          net::post(
            strand,
            [handler = std::forward<decltype(handler)>(handler), work = std::move(work)]() mutable {
              net::dispatch(work, [handler = std::move(handler)]() mutable {
                std::move(handler)(refuse_holdings());
              });
            }
          );
        },
        token
      );
    }
    return client.async_holdings(account, std::forward<Token>(token));
  }

  template <typename Token>
  static auto place_order(
    Client& client,
    const Account& account,
    OrderRequest order,
    Token&& token
  ) {
    return client.async_place_order(account, std::move(order), std::forward<Token>(token));
  }

  template <typename Token>
  static auto replace_order(
    Client& client,
    const Account& account,
    Amendment amendment,
    Token&& token
  ) {
    return client.async_replace_order(account, std::move(amendment), std::forward<Token>(token));
  }

  template <typename Token>
  static auto cancel_order(
    Client& client,
    const Account& account,
    Amendment amendment,
    Token&& token
  ) {
    return client.async_cancel_order(account, std::move(amendment), std::forward<Token>(token));
  }

  template <typename Token>
  static auto working_orders(Client& client, const Account& account, Token&& token) {
    return client.async_open_orders(account, std::forward<Token>(token));
  }

  template <typename Token>
  static auto order_history(
    Client& client,
    const Account& account,
    HistoryQuery query,
    Token&& token
  ) {
    return client.async_order_history(account, std::move(query), std::forward<Token>(token));
  }
};

template <>
struct BrokerTraits<kiwoom::KiwoomBlockingClient>
: kiwoom::traits_detail::Normalizers, kiwoom::traits_detail::Capabilities {
  static constexpr Venue effective_route(Venue asked) noexcept { return kiwoom_route(asked); }

  using Client = kiwoom::KiwoomBlockingClient;

  using Config = kiwoom::KiwoomConfig;

  using Account = kiwoom::KiwoomAccount;

  using AccountListItem = kiwoom::KiwoomAccountInfo;

  using BrokerTag = kiwoom::Broker;

  using PlaceAck = kiwoom::KiwoomOrderAck;

  using Amendment = kiwoom::KiwoomAmendment;

  using HistoryQuery = kiwoom::KiwoomHistoryQuery;

  using WorkingOrdersResult = kiwoom::KiwoomOpenOrderPage;

  static constexpr std::string_view name = kiwoom::Broker::name;

  static constexpr bool blocking = true;

  static const network::RateLimitStats* rate_limit_stats(const Client& client) {
    return client.rate_limit_stats();
  }

  static Result<QuoteSnapshot> quote(Client& client, InstrumentId instrument) {
    return client.quote(std::move(instrument));
  }

  static Result<PriceLimits> price_limits(Client& client, InstrumentId instrument) {
    return client.price_limits(std::move(instrument));
  }

  static Result<std::vector<TradePrint>> trades(
    Client& client,
    InstrumentId instrument,
    int count
  ) {
    return client.trades(std::move(instrument), count);
  }

  static Result<DepthSnapshot> depth(Client& client, InstrumentId instrument) {
    return client.depth(std::move(instrument));
  }

  static Result<BarSeries> bars(Client& client, BarQuery query) {
    return client.bars(std::move(query));
  }

  static Result<Instrument> instrument(Client& client, InstrumentId subject) {
    return client.instrument(std::move(subject));
  }

  static Result<std::vector<AccountListItem>> accounts(Client& client) {
    return client.accounts();
  }

  static Result<HoldingsSnapshot> holdings(Client& client, const Account& account) {
    if (!kiwoom::kiwoom_position_scope_asserted(client.config().holdings_position_scope_)) {
      static_cast<void>(account);
      return refuse_holdings();
    }
    return client.holdings(account);
  }

  static Result<BuyingPower> buying_power(
    Client& client,
    const Account& account,
    Currency currency
  ) {
    return client.buying_power(currency, account);
  }

  static Result<PlaceAck> place_order(Client& client, const Account& account, OrderRequest order) {
    return client.place_order(account, std::move(order));
  }

  static Result<PlaceAck> replace_order(
    Client& client,
    const Account& account,
    Amendment amendment
  ) {
    return client.replace_order(account, std::move(amendment));
  }

  static Result<PlaceAck> cancel_order(
    Client& client,
    const Account& account,
    Amendment amendment
  ) {
    return client.cancel_order(account, std::move(amendment));
  }

  static Result<WorkingOrdersResult> working_orders(Client& client, const Account& account) {
    return client.open_orders(account);
  }

  static Result<OrderPage> order_history(
    Client& client,
    const Account& account,
    HistoryQuery query
  ) {
    return client.order_history(account, std::move(query));
  }
};
 
} // namespace algotradelib