traits.hpp

#pragma once

#define ATL_BROKER_ADAPTER_PRESENT 1
 
#include "./client.hpp"
 
#include "../../core/broker_session.hpp"
#include "../../core/broker_traits.hpp"
 
#include <optional>
#include <string>
#include <utility>
 
namespace algotradelib {
 
namespace kis {

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

using Ref = OrderRef<kis::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 = false;

  static constexpr SellableSource sellable_source = SellableSource::HOLDINGS;

  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 = true;

  static constexpr bool has_calendar_range = true;

  static constexpr bool has_calendar_sessions = false;

  static std::optional<BrokerError> validate_calendar(Country country, std::optional<Date> from) {
    BrokerError error;
    error.category_ = ErrorCategory::INVALID_ARGUMENT;
    error.reached_broker_ = false;
    if (country != Country::KR) {
      error.broker_code_ = "unsupported_market";
      error.message_ = "KIS publishes the domestic trading calendar only";
      return error;
    }
    if (from && !is_valid_date(*from)) {
      error.broker_code_ = "invalid_date";
      error.message_ = "calendar request requires a valid Gregorian date";
      return error;
    }
    return std::nullopt;
  }

  static constexpr bool supports_interval(BarInterval interval) {
    return kis::publishes_bar_interval(interval);
  }

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

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

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

  static std::optional<BrokerError> validate_place(const OrderRequest& order) {
    return kis::unsupported_client_order_id(order);
  }

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

  static Result<WorkingOrders<kis::Broker>> normalize_working_orders(
    Result<KisOpenOrderPage> raw
  ) {
    if (!raw) {
      return Result<WorkingOrders<kis::Broker>>(std::move(raw.error()));
    }
    WorkingOrders<kis::Broker> orders;
    orders.received_at_ = raw.value().received_at_;
    orders.orders_.reserve(raw.value().orders_.size());
    for (auto& open_order : raw.value().orders_) {
      WorkingOrder<kis::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<kis::Broker>>(std::move(orders));
  }

  static Result<KisAmendment> to_amendment(
    const Ref& ref,
    const AmendInstruction& instruction
  ) {
    if (!instruction.quantity_) {
      BrokerError error;
      error.category_ = ErrorCategory::INVALID_ARGUMENT;
      error.reached_broker_ = false;
      error.broker_code_ = "quantity_required";
      error.message_ =
        "KIS requires an explicit quantity on a modification or cancellation, including a full "
        "cancellation; read the amendable quantity from working orders first";
      return Result<KisAmendment>(std::move(error));
    }
 
    KisAmendment amendment;
    amendment.order_ = from_ref(ref);
    // What the shape leaves unset stays as it is, which the resting shape says.
    // KIS composes one `ORD_DVSN` from all three, so it cannot send an
    // amendment with a condition or session it does not know -- an unset field
    // with no resting shape to resolve it from is refused rather than defaulted,
    // because defaulting it here is how `00` got sent for an IOC order.
    const auto condition = instruction.shape_.time_in_force_
      ? instruction.shape_.time_in_force_
      : (instruction.resting_ ? instruction.resting_->time_in_force_ : std::nullopt);
    const auto session = instruction.shape_.session_
      ? instruction.shape_.session_
      : (instruction.resting_ ? instruction.resting_->session_ : std::nullopt);
    if (!condition || !session) {
      BrokerError error;
      error.category_ = ErrorCategory::INVALID_ARGUMENT;
      error.reached_broker_ = false;
      error.broker_code_ = "incomplete_shape";
      error.message_ =
        "KIS re-sends the order code on an amendment and cannot compose one without the order's "
        "validity condition and session; state them on the shape or build the instruction with "
        "reprice() or replace_with(), which take them from the resting order";
      return Result<KisAmendment>(std::move(error));
    }
    amendment.type_ = instruction.shape_.type_;
    amendment.time_in_force_ = *condition;
    amendment.session_ = *session;
    amendment.venue_ = instruction.venue_;
    amendment.quantity_ = *instruction.quantity_;
    amendment.price_ = instruction.shape_.price_;
    amendment.trigger_price_ = amended_trigger_price(instruction);
    amendment.all_remaining_ = instruction.all_remaining_;
    return Result<KisAmendment>(std::move(amendment));
  }

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

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

  static Result<KisHistoryRange> to_history_query(
    const KisAccount&,
    const OrderHistoryQuery& query
  ) {
    BrokerError error;
    error.category_ = ErrorCategory::INVALID_ARGUMENT;
    error.reached_broker_ = false;
    if (!query.from_ || !query.to_) {
      error.broker_code_ = "range_required";
      error.message_ = "KIS order history requires an inclusive from and to calendar date";
      return Result<KisHistoryRange>(std::move(error));
    }
    if (query.symbol_) {
      error.broker_code_ = "symbol_filter_unsupported";
      error.message_ =
        "KIS order history is not filtered by instrument by this adapter; filter the returned "
        "orders instead";
      return Result<KisHistoryRange>(std::move(error));
    }
    if (query.cursor_) {
      error.broker_code_ = "cursor_unsupported";
      error.message_ = "KIS order history pages internally and exposes no cursor";
      return Result<KisHistoryRange>(std::move(error));
    }
    if (query.limit_) {
      error.broker_code_ = "limit_unsupported";
      error.message_ = "KIS order history returns every page and cannot honor a row limit";
      return Result<KisHistoryRange>(std::move(error));
    }
    return Result<KisHistoryRange>(KisHistoryRange{*query.from_, *query.to_});
  }
};

struct Capabilities {
  static constexpr bool has_account_discovery = false;

  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 = true;

  static constexpr bool has_history_cursor = false;

  static constexpr bool has_history_limit = false;

  static constexpr bool has_history_symbol_filter = false;
};
 
} // namespace traits_detail
} // namespace kis

inline constexpr Venue kis_effective_route(Venue asked) noexcept {
  return asked == Venue::UNSPECIFIED ? Venue::KRX : asked;
}

template <>
struct BrokerTraits<kis::KisClient>
: kis::traits_detail::Normalizers, kis::traits_detail::Capabilities {
  static constexpr Venue effective_route(Venue asked) noexcept {
    return kis_effective_route(asked);
  }

  using Client = kis::KisClient;

  using Config = kis::KisConfig;

  using Account = kis::KisAccount;

  using BrokerTag = kis::Broker;

  using PlaceAck = kis::KisOrderAck;

  using Amendment = kis::KisAmendment;

  using HistoryQuery = kis::KisHistoryRange;

  using WorkingOrdersResult = kis::KisOpenOrderPage;

  static constexpr std::string_view name = kis::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 instrument(Client& client, InstrumentId subject, Token&& token) {
    return client.async_instrument(std::move(subject), std::forward<Token>(token));
  }

  template <typename Token>
  static auto calendar(Client& client, Country, std::optional<Date> from, Token&& token) {
    return client.async_calendar(
      from ? *from : kis::today_in_seoul(), false, 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 quote(Client& client, InstrumentId instrument, Token&& token) {
    return client.async_quote(std::move(instrument), 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) {
    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, query, std::forward<Token>(token));
  }
};

template <>
struct BrokerTraits<kis::KisBlockingClient>
: kis::traits_detail::Normalizers, kis::traits_detail::Capabilities {
  static constexpr Venue effective_route(Venue asked) noexcept {
    return kis_effective_route(asked);
  }

  using Client = kis::KisBlockingClient;

  using Config = kis::KisConfig;

  using Account = kis::KisAccount;

  using BrokerTag = kis::Broker;

  using PlaceAck = kis::KisOrderAck;

  using Amendment = kis::KisAmendment;

  using HistoryQuery = kis::KisHistoryRange;

  using WorkingOrdersResult = kis::KisOpenOrderPage;

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

  static constexpr bool blocking = true;

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

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

  static Result<TradingCalendar> calendar(Client& client, Country, std::optional<Date> from) {
    return client.calendar(from ? *from : kis::today_in_seoul());
  }

  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<QuoteSnapshot> quote(Client& client, InstrumentId instrument) {
    return client.quote(std::move(instrument));
  }

  static Result<HoldingsSnapshot> holdings(Client& client, const Account& account) {
    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, query);
  }
};
 
} // namespace algotradelib