types.hpp

#pragma once
 
#include <array>
#include <chrono>
#include <cstddef>
#include <functional>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <limits>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <utility>
#include <variant>
#include <vector>
 
#include "./enum_values.hpp"
 
namespace algotradelib {

enum class Country {
  KR,
  US,
};

inline constexpr std::array<Country, 2> all_countries{Country::KR, Country::US};

enum class Venue {
  UNSPECIFIED,
  KRX,
  NXT,
  COMBINED,
};

inline constexpr std::array<Venue, 4> all_venues{Venue::UNSPECIFIED, Venue::KRX, Venue::NXT, Venue::COMBINED};

inline constexpr std::string_view venue_name(Venue venue) noexcept {
  switch (venue) {
    case Venue::UNSPECIFIED:
      return "unspecified";
    case Venue::KRX:
      return "KRX";
    case Venue::NXT:
      return "NXT";
    case Venue::COMBINED:
      return "COMBINED";
  }
  return "";
}
 
static_assert(
  lists_every_value(all_venues, [](Venue venue) { return !venue_name(venue).empty(); }),
  "all_venues must list every Venue"
);

struct InstrumentId {
  Country country_{Country::KR};
  Venue venue_{Venue::COMBINED};
  std::string symbol_;

  friend bool operator==(const InstrumentId& lhs, const InstrumentId& rhs) {
    return lhs.country_ == rhs.country_ && lhs.venue_ == rhs.venue_ && lhs.symbol_ == rhs.symbol_;
  }

  friend bool operator<(const InstrumentId& lhs, const InstrumentId& rhs) {
    if (lhs.country_ != rhs.country_) {
      return lhs.country_ < rhs.country_;
    }
    if (lhs.venue_ != rhs.venue_) {
      return lhs.venue_ < rhs.venue_;
    }
    return lhs.symbol_ < rhs.symbol_;
  }
};

template <std::size_t N>
class Code {
public:
  Code() = default;

  explicit Code(std::string_view text) {
    if (text.size() > N) {
      throw std::invalid_argument("code is longer than its capacity");
    }
    for (std::size_t i = 0; i < text.size(); ++i) {
      const char ch = text[i];
      const bool valid = (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_';
      if (!valid) {
        throw std::invalid_argument("code must use uppercase ASCII, digits, or underscore");
      }
      characters_[i] = ch;
    }
    size_ = static_cast<std::uint8_t>(text.size());
  }

  static std::optional<Code> try_make(std::string_view text) {
    if (text.size() > N) {
      return std::nullopt;
    }
    Code code;
    for (std::size_t i = 0; i < text.size(); ++i) {
      const char ch = text[i];
      const bool valid = (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_';
      if (!valid) {
        return std::nullopt;
      }
      code.characters_[i] = ch;
    }
    code.size_ = static_cast<std::uint8_t>(text.size());
    return code;
  }

  std::string_view view() const noexcept {
    return std::string_view(characters_.data(), size_);
  }

  std::string str() const { return std::string(view()); }

  bool empty() const noexcept { return size_ == 0; }

  std::size_t size() const noexcept { return size_; }

  static constexpr std::size_t capacity() noexcept { return N; }

  friend bool operator==(const Code& lhs, const Code& rhs) { return lhs.view() == rhs.view(); }

  friend bool operator!=(const Code& lhs, const Code& rhs) { return !(lhs == rhs); }
 
private:
  std::array<char, N> characters_{};
  std::uint8_t size_{0};
};

class Currency {
public:
  Currency() : code_{'K', 'R', 'W'} {}

  explicit Currency(std::string_view code) {
    if (code.size() != code_.size()) {
      throw std::invalid_argument("currency code must contain three characters");
    }
    for (std::size_t i = 0; i < code_.size(); ++i) {
      const char ch = code[i];
      if (ch < 'A' || ch > 'Z') {
        throw std::invalid_argument("currency code must use uppercase ASCII characters");
      }
      code_[i] = ch;
    }
  }

  static Currency krw() { return Currency("KRW"); }

  static Currency usd() { return Currency("USD"); }

  std::string str() const { return std::string(code_.begin(), code_.end()); }

  friend bool operator==(const Currency& lhs, const Currency& rhs) {
    return lhs.code_ == rhs.code_;
  }
 
private:
  std::array<char, 3> code_{};
};

class Decimal64 {
public:
  Decimal64() = default;

  Decimal64(std::int64_t coefficient, std::uint8_t scale)
  : coefficient_(coefficient), scale_(scale) {}

  static Decimal64 parse(std::string_view input) {
    if (input.empty()) {
      throw std::invalid_argument("decimal value is empty");
    }
 
    bool negative = false;
    std::size_t index = 0;
    if (input.front() == '+' || input.front() == '-') {
      negative = input.front() == '-';
      index = 1;
    }
    if (index == input.size()) {
      throw std::invalid_argument("decimal value has no digits");
    }
 
    std::uint64_t magnitude = 0;
    std::uint8_t scale = 0;
    bool decimal_point = false;
    bool has_digit = false;
    const std::uint64_t limit = negative ?
      static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max()) + 1ULL :
      static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max());
 
    for (; index < input.size(); ++index) {
      const char ch = input[index];
      if (ch == '.') {
        if (decimal_point) {
          throw std::invalid_argument("decimal value contains multiple points");
        }
        decimal_point = true;
        continue;
      }
      if (ch < '0' || ch > '9') {
        throw std::invalid_argument("decimal value contains an invalid character");
      }
      has_digit = true;
      const auto digit = static_cast<std::uint64_t>(ch - '0');
      if (magnitude > (limit - digit) / 10ULL) {
        throw std::out_of_range("decimal value exceeds Decimal64 range");
      }
      magnitude = magnitude * 10ULL + digit;
      if (decimal_point) {
        if (scale == std::numeric_limits<std::uint8_t>::max()) {
          throw std::out_of_range("decimal scale exceeds Decimal64 range");
        }
        ++scale;
      }
    }
    if (!has_digit) {
      throw std::invalid_argument("decimal value has no digits");
    }
 
    while (scale > 0 && magnitude % 10ULL == 0) {
      magnitude /= 10ULL;
      --scale;
    }
 
    std::int64_t coefficient;
    if (
      negative &&
      magnitude == static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max()) + 1ULL
    ) {
      coefficient = std::numeric_limits<std::int64_t>::min();
    } else {
      coefficient = static_cast<std::int64_t>(magnitude);
      if (negative) {
        coefficient = -coefficient;
      }
    }
    return Decimal64(coefficient, scale);
  }

  std::int64_t coefficient() const noexcept { return coefficient_; }

  std::uint8_t scale() const noexcept { return scale_; }

  std::string str() const {
    const bool negative = coefficient_ < 0;
    std::uint64_t magnitude = negative ?
      static_cast<std::uint64_t>(-(coefficient_ + 1)) + 1ULL :
      static_cast<std::uint64_t>(coefficient_);
    std::string digits = std::to_string(magnitude);
    if (scale_ > 0) {
      if (digits.size() <= scale_) {
        digits.insert(0, static_cast<std::size_t>(scale_) - digits.size() + 1, '0');
      }
      digits.insert(digits.size() - scale_, 1, '.');
    }
    if (negative) {
      digits.insert(digits.begin(), '-');
    }
    return digits;
  }

  friend bool operator==(const Decimal64& lhs, const Decimal64& rhs) {
    return lhs.coefficient_ == rhs.coefficient_ && lhs.scale_ == rhs.scale_;
  }
 
private:
  std::int64_t coefficient_{0};
  std::uint8_t scale_{0};
};

inline Decimal64 decimal_normalized(const Decimal64& value) {
  auto coefficient = value.coefficient();
  auto scale = value.scale();
  while (scale > 0 && coefficient % 10 == 0) {
    coefficient /= 10;
    --scale;
  }
  return Decimal64(coefficient, scale);
}
 
namespace decimal_detail {

inline bool align(
  const Decimal64& lhs,
  const Decimal64& rhs,
  std::int64_t& left,
  std::int64_t& right,
  std::uint8_t& scale
) {
  scale = lhs.scale() > rhs.scale() ? lhs.scale() : rhs.scale();
  left = lhs.coefficient();
  right = rhs.coefficient();
  for (std::uint8_t step = lhs.scale(); step < scale; ++step) {
    if (left > std::numeric_limits<std::int64_t>::max() / 10 ||
        left < std::numeric_limits<std::int64_t>::min() / 10) {
      return false;
    }
    left *= 10;
  }
  for (std::uint8_t step = rhs.scale(); step < scale; ++step) {
    if (right > std::numeric_limits<std::int64_t>::max() / 10 ||
        right < std::numeric_limits<std::int64_t>::min() / 10) {
      return false;
    }
    right *= 10;
  }
  return true;
}
 
} // namespace decimal_detail

inline std::optional<Decimal64> decimal_add(const Decimal64& lhs, const Decimal64& rhs) {
  std::int64_t left = 0;
  std::int64_t right = 0;
  std::uint8_t scale = 0;
  if (!decimal_detail::align(lhs, rhs, left, right, scale)) {
    return std::nullopt;
  }
  if ((right > 0 && left > std::numeric_limits<std::int64_t>::max() - right) ||
      (right < 0 && left < std::numeric_limits<std::int64_t>::min() - right)) {
    return std::nullopt;
  }
  return decimal_normalized(Decimal64(left + right, scale));
}

inline std::optional<Decimal64> decimal_subtract(const Decimal64& lhs, const Decimal64& rhs) {
  std::int64_t left = 0;
  std::int64_t right = 0;
  std::uint8_t scale = 0;
  if (!decimal_detail::align(lhs, rhs, left, right, scale)) {
    return std::nullopt;
  }
  if ((right < 0 && left > std::numeric_limits<std::int64_t>::max() + right) ||
      (right > 0 && left < std::numeric_limits<std::int64_t>::min() + right)) {
    return std::nullopt;
  }
  return decimal_normalized(Decimal64(left - right, scale));
}

inline std::optional<Decimal64> decimal_halve(const Decimal64& value) {
  const auto coefficient = value.coefficient();
  if (coefficient % 2 == 0) {
    return decimal_normalized(Decimal64(coefficient / 2, value.scale()));
  }
  if (value.scale() == std::numeric_limits<std::uint8_t>::max() ||
      coefficient > std::numeric_limits<std::int64_t>::max() / 5 ||
      coefficient < std::numeric_limits<std::int64_t>::min() / 5) {
    return std::nullopt;
  }
  return decimal_normalized(
    Decimal64(coefficient * 5, static_cast<std::uint8_t>(value.scale() + 1))
  );
}

inline std::optional<Decimal64> decimal_multiply(const Decimal64& lhs, const Decimal64& rhs) {
  const auto left = lhs.coefficient();
  const auto right = rhs.coefficient();
  const int scale = static_cast<int>(lhs.scale()) + static_cast<int>(rhs.scale());
  if (scale > std::numeric_limits<std::uint8_t>::max()) {
    return std::nullopt;
  }
  if (left != 0 && right != 0) {
    // Checked before multiplying rather than after, because signed overflow is undefined and a
    // wrapped price is exactly the failure this type exists to prevent.
    if (left > 0 ? (right > 0 ? left > std::numeric_limits<std::int64_t>::max() / right
                              : right < std::numeric_limits<std::int64_t>::min() / left)
                 : (right > 0 ? left < std::numeric_limits<std::int64_t>::min() / right
                              : left < std::numeric_limits<std::int64_t>::max() / right)) {
      return std::nullopt;
    }
  }
  return decimal_normalized(Decimal64(left * right, static_cast<std::uint8_t>(scale)));
}

inline std::optional<Decimal64> decimal_divide(
  const Decimal64& lhs,
  const Decimal64& rhs,
  std::uint8_t scale
) {
  std::int64_t left = 0;
  std::int64_t right = 0;
  std::uint8_t common = 0;
  if (!decimal_detail::align(lhs, rhs, left, right, common) || right == 0) {
    return std::nullopt;
  }
  // Aligning cancels the scales, so `left / right` is the plain ratio. Each requested decimal
  // place is one more factor of ten taken before the division.
  for (std::uint8_t step = 0; step < scale; ++step) {
    if (left > std::numeric_limits<std::int64_t>::max() / 10 ||
        left < std::numeric_limits<std::int64_t>::min() / 10) {
      return std::nullopt;
    }
    left *= 10;
  }
  if (left == std::numeric_limits<std::int64_t>::min() && right == -1) {
    return std::nullopt;
  }
  return decimal_normalized(Decimal64(left / right, scale));
}

inline std::optional<Decimal64> decimal_floor_to_multiple(
  const Decimal64& value,
  const Decimal64& step
) {
  std::int64_t left = 0;
  std::int64_t right = 0;
  std::uint8_t scale = 0;
  if (!decimal_detail::align(value, step, left, right, scale) || right <= 0) {
    return std::nullopt;
  }
  auto rest = left % right;
  if (rest < 0) {
    rest += right;
  }
  if (left < std::numeric_limits<std::int64_t>::min() + rest) {
    return std::nullopt;
  }
  return decimal_normalized(Decimal64(left - rest, scale));
}

inline bool decimal_less(const Decimal64& lhs, const Decimal64& rhs) {
  std::int64_t left = 0;
  std::int64_t right = 0;
  std::uint8_t scale = 0;
  if (decimal_detail::align(lhs, rhs, left, right, scale)) {
    return left < right;
  }
  // Rescaling overflowed, so the values differ by more than any shared scale can
  // express: the one with the smaller scale has the larger magnitude. Between two
  // negatives the larger magnitude is the smaller value.
  const bool left_negative = lhs.coefficient() < 0;
  if (left_negative != (rhs.coefficient() < 0)) {
    return left_negative;
  }
  return left_negative ? lhs.scale() < rhs.scale() : lhs.scale() > rhs.scale();
}

enum class ErrorCategory {
  CANCELLED,
  TRANSPORT,
  HTTP,
  AUTHENTICATION,
  RATE_LIMIT,
  PROTOCOL,
  INVALID_ARGUMENT,
};

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

struct BrokerError {
  ErrorCategory category_{ErrorCategory::PROTOCOL};
  bool reached_broker_{true};
  int http_status_{0};
  std::string broker_code_;
  std::string request_id_;
  std::string message_;
  std::optional<std::chrono::seconds> retry_after_;
  std::optional<int> rate_limit_;
};

template <typename T>
class Result {
public:
  Result(T value) : value_(std::move(value)) {}

  Result(BrokerError error) : value_(std::move(error)) {}

  bool has_value() const noexcept { return std::holds_alternative<T>(value_); }

  explicit operator bool() const noexcept { return has_value(); }

  T& value() { return std::get<T>(value_); }

  const T& value() const { return std::get<T>(value_); }

  BrokerError& error() { return std::get<BrokerError>(value_); }

  const BrokerError& error() const { return std::get<BrokerError>(value_); }
 
private:
  std::variant<T, BrokerError> value_;
};

struct TopOfBook {
  std::optional<Decimal64> bid_price_;
  std::optional<Decimal64> bid_quantity_;
  std::optional<Decimal64> ask_price_;
  std::optional<Decimal64> ask_quantity_;
};

struct QuoteSnapshot {
  InstrumentId instrument_;
  Decimal64 last_price_;
  Currency currency_;
  std::optional<std::chrono::system_clock::time_point> exchange_time_;
  std::chrono::system_clock::time_point received_at_;

  std::optional<TopOfBook> top_of_book_;
  std::optional<Decimal64> volume_;
};

struct Money {
  Decimal64 amount_;
  Currency currency_;

  friend bool operator==(const Money& lhs, const Money& rhs) {
    return lhs.amount_ == rhs.amount_ && lhs.currency_ == rhs.currency_;
  }
};

struct SellableBasis {
  enum class Coverage {
    UNESTABLISHED,
    WHOLE_HOLDING,
    PARTIAL,
  };

  enum class RestingTreatment {
    UNESTABLISHED,
    DEDUCT,
  };

  Coverage coverage_ = Coverage::UNESTABLISHED;
  RestingTreatment resting_ = RestingTreatment::UNESTABLISHED;
  bool verified_ = false;

  constexpr bool is_enforceable() const noexcept {
    bool covers = false;
    switch (coverage_) {
      case Coverage::WHOLE_HOLDING:
        covers = true;
        break;
      case Coverage::UNESTABLISHED:
      case Coverage::PARTIAL:
        break;
    }
    bool treated = false;
    switch (resting_) {
      case RestingTreatment::DEDUCT:
        treated = true;
        break;
      case RestingTreatment::UNESTABLISHED:
        break;
    }
    return covers && treated;
  }
};

inline constexpr std::string_view sellable_coverage_name(SellableBasis::Coverage coverage
) noexcept {
  switch (coverage) {
    case SellableBasis::Coverage::UNESTABLISHED:
      return "unestablished";
    case SellableBasis::Coverage::WHOLE_HOLDING:
      return "whole_holding";
    case SellableBasis::Coverage::PARTIAL:
      return "partial";
  }
  return "unestablished";
}

inline constexpr std::string_view sellable_resting_name(SellableBasis::RestingTreatment treatment
) noexcept {
  switch (treatment) {
    case SellableBasis::RestingTreatment::UNESTABLISHED:
      return "unestablished";
    case SellableBasis::RestingTreatment::DEDUCT:
      return "deduct";
  }
  return "unestablished";
}

struct HoldingPosition {
  InstrumentId instrument_;
  std::string name_;
  Decimal64 quantity_;
  std::optional<Decimal64> sellable_quantity_;
  std::optional<SellableBasis> sellable_basis_;
  Decimal64 average_purchase_price_;
  Decimal64 last_price_;
  Money purchase_value_;
  Money market_value_;
  Money unrealized_profit_loss_;
  Decimal64 unrealized_return_;
};

struct HoldingsTotals {
  Currency currency_;
  Decimal64 purchase_value_;
  Decimal64 market_value_;
  Decimal64 unrealized_profit_loss_;
};
 

struct HoldingsSnapshot {
  std::vector<HoldingPosition> positions_;
  std::vector<HoldingsTotals> totals_;
  std::chrono::system_clock::time_point received_at_;
  SellableBasis sellable_basis_;
};

enum class SellableSource {
  HOLDINGS,
  INQUIRY,
  NONE,
};

inline constexpr std::string_view sellable_source_name(SellableSource source) noexcept {
  switch (source) {
    case SellableSource::HOLDINGS:
      return "holdings";
    case SellableSource::INQUIRY:
      return "inquiry";
    case SellableSource::NONE:
      return "none";
  }
  return "none";
}

struct BuyingPower {
  Money cash_;
  std::chrono::system_clock::time_point received_at_{};
};

struct Date {
  int year_{0};
  unsigned month_{0};
  unsigned day_{0};

  friend bool operator==(const Date& lhs, const Date& rhs) {
    return lhs.year_ == rhs.year_ && lhs.month_ == rhs.month_ && lhs.day_ == rhs.day_;
  }

  friend bool operator<(const Date& lhs, const Date& rhs) {
    if (lhs.year_ != rhs.year_) {
      return lhs.year_ < rhs.year_;
    }
    if (lhs.month_ != rhs.month_) {
      return lhs.month_ < rhs.month_;
    }
    return lhs.day_ < rhs.day_;
  }
};

inline Date date_from_epoch_days(std::int64_t days) {
  // Shifts the era so that the year starts in March, which is what removes the leap-day special
  // case from everything below: 1970-01-01 is 719468 days after 0000-03-01.
  const std::int64_t shifted = days + 719468;
  const std::int64_t era = (shifted >= 0 ? shifted : shifted - 146096) / 146097;
  const std::int64_t day_of_era = shifted - era * 146097;
  const std::int64_t year_of_era =
    (day_of_era - day_of_era / 1460 + day_of_era / 36524 - day_of_era / 146096) / 365;
  const std::int64_t year = year_of_era + era * 400;
  const std::int64_t day_of_year =
    day_of_era - (365 * year_of_era + year_of_era / 4 - year_of_era / 100);
  const std::int64_t shifted_month = (5 * day_of_year + 2) / 153;
  const std::int64_t day = day_of_year - (153 * shifted_month + 2) / 5 + 1;
  const std::int64_t month = shifted_month + (shifted_month < 10 ? 3 : -9);
  return Date{
    static_cast<int>(year + (month <= 2 ? 1 : 0)),
    static_cast<unsigned>(month),
    static_cast<unsigned>(day),
  };
}

inline bool is_valid_date(const Date& date) {
  if (date.year_ < 1 || date.year_ > 9999 || date.month_ < 1 || date.month_ > 12) {
    return false;
  }
  static constexpr unsigned days_per_month[] = {
    31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
  };
  unsigned days = days_per_month[date.month_ - 1];
  const bool leap = date.year_ % 4 == 0 && (date.year_ % 100 != 0 || date.year_ % 400 == 0);
  if (date.month_ == 2 && leap) {
    ++days;
  }
  return date.day_ >= 1 && date.day_ <= days;
}

enum class VenueKeyKind {
  ANY,
  NORMALIZED,
  RAW,
};

class VenueKey {
public:
  VenueKey() = default;

  static VenueKey any() noexcept { return VenueKey(); }

  static std::optional<VenueKey> normalized(Venue venue) {
    if (venue == Venue::UNSPECIFIED) {
      return std::nullopt;
    }
    VenueKey key;
    key.kind_ = VenueKeyKind::NORMALIZED;
    key.venue_ = venue;
    return key;
  }

  static std::optional<VenueKey> raw(std::string_view code) {
    auto stored = Code<8>::try_make(code);
    if (!stored || stored->empty()) {
      return std::nullopt;
    }
    VenueKey key;
    key.kind_ = VenueKeyKind::RAW;
    key.raw_ = *stored;
    return key;
  }

  VenueKeyKind kind() const noexcept { return kind_; }

  bool is_any() const noexcept { return kind_ == VenueKeyKind::ANY; }

  Venue venue() const noexcept { return venue_; }

  const Code<8>& raw_code() const noexcept { return raw_; }

  bool matches(const VenueKey& asserted) const noexcept {
    if (kind_ != asserted.kind_) {
      return false;
    }
    switch (kind_) {
      case VenueKeyKind::ANY:
        return true;
      case VenueKeyKind::NORMALIZED:
        return venue_ == asserted.venue_;
      case VenueKeyKind::RAW:
        return raw_ == asserted.raw_;
    }
    return false;
  }

  friend bool operator==(const VenueKey& lhs, const VenueKey& rhs) noexcept { return lhs.matches(rhs); }

  friend bool operator!=(const VenueKey& lhs, const VenueKey& rhs) noexcept { return !(lhs == rhs); }
 
private:
  VenueKeyKind kind_{VenueKeyKind::ANY};
  Venue venue_{Venue::UNSPECIFIED};
  Code<8> raw_;
};

inline constexpr std::string_view venue_key_kind_name(VenueKeyKind kind) noexcept {
  switch (kind) {
    case VenueKeyKind::ANY:
      return "any";
    case VenueKeyKind::NORMALIZED:
      return "normalized";
    case VenueKeyKind::RAW:
      return "raw";
  }
  return "unknown";
}

enum class CommissionOrigin {
  BROKER_PUBLISHED,
  CALLER_STATED,
};

inline constexpr bool commission_origin_is_broker(CommissionOrigin origin) noexcept {
  switch (origin) {
    case CommissionOrigin::BROKER_PUBLISHED:
      return true;
    case CommissionOrigin::CALLER_STATED:
      return false;
  }
  return false;
}

inline constexpr bool commission_origin_names_tariff(CommissionOrigin origin) noexcept {
  switch (origin) {
    case CommissionOrigin::CALLER_STATED:
      return true;
    case CommissionOrigin::BROKER_PUBLISHED:
      return false;
  }
  return true;
}

inline constexpr std::string_view commission_origin_name(CommissionOrigin origin) noexcept {
  switch (origin) {
    case CommissionOrigin::BROKER_PUBLISHED:
      return "broker_published";
    case CommissionOrigin::CALLER_STATED:
      return "caller_stated";
  }
  return "unknown";
}

enum class RateApplicability {
  NO,
  YES,
  UNREADABLE,
};

struct CommissionRate {
  Country country_{Country::KR};
  Code<16> other_;
  VenueKey venue_;
  Decimal64 rate_;
  std::optional<Decimal64> institution_rate_;
  std::optional<Date> from_;
  std::optional<Date> until_;
  bool from_unreadable_{false};
  bool until_unreadable_{false};

  bool normalized() const noexcept { return other_.empty(); }

  RateApplicability applies_on(const Date& date) const {
    if (excluded_on(date)) {
      return RateApplicability::NO;
    }
    if (from_unreadable_ || until_unreadable_) {
      return RateApplicability::UNREADABLE;
    }
    return RateApplicability::YES;
  }

  bool excluded_on(const Date& date) const {
    return (from_ && date < *from_) || (until_ && *until_ < date);
  }
};

struct CommissionSchedule {
  std::vector<CommissionRate> rates_;
  std::chrono::system_clock::time_point received_at_{};
  CommissionOrigin origin_{CommissionOrigin::BROKER_PUBLISHED};
  std::string tariff_;

  std::size_t dropped_{0};

  std::size_t unreadable_bounds_{0};

  struct RateSelection {
    std::optional<CommissionRate> rate_;
    bool bounds_unreadable_{false};
  };

  RateSelection rate_for(
    Country country,
    const VenueKey& asserted,
    const Date& date
  ) const {
    // A row for a market this library does not normalize can never be the answer to a question asked
    // in terms of `Country`, and it is kept so a caller can see that the broker sent it.
    const auto in_market = [&](const CommissionRate& rate) {
      return rate.normalized() && rate.country_ == country;
    };
    // **Each pass stops at the first row that decides it, and an unreadable row decides it too.**
    // Within a pass the first match has always won, so a damaged row *after* a definite match could
    // never have been the answer and is not a reason to refuse -- scanning the whole pass first would
    // throw away an answer this library knows. A damaged row reached *before* any match is the
    // opposite case: it may have been the match, so nothing later in the pass can be trusted to be
    // the winner.
    const auto pass = [&](bool venue_specific) -> std::optional<RateSelection> {
      for (const auto& rate : rates_) {
        if (!in_market(rate)) {
          continue;
        }
        if (!(venue_specific ? rate.venue_.matches(asserted) : rate.venue_.is_any())) {
          continue;
        }
        switch (rate.applies_on(date)) {
          case RateApplicability::NO:
            continue;
          case RateApplicability::YES: {
            RateSelection found;
            found.rate_ = rate;
            return found;
          }
          case RateApplicability::UNREADABLE: {
            RateSelection refused;
            refused.bounds_unreadable_ = true;
            return refused;
          }
        }
      }
      return std::nullopt;
    };
    // An undecided pass one falls through; a *refused* pass one does not. Pass two's precondition is
    // "no row for the asserted venue applies", and that is precisely what stopped being known.
    if (const auto venue_row = pass(true)) {
      return *venue_row;
    }
    if (const auto neutral_row = pass(false)) {
      return *neutral_row;
    }
    return RateSelection{};
  }

  bool any_dated_rate_for(Country country) const {
    for (const auto& rate : rates_) {
      // A bound that could not be read is still a bound the source stated. Asking only whether the
      // optionals are filled would read a row dated *solely* by damage as undated, and hand the
      // caller the very "every candidate is the same whichever calendar named the day" assurance
      // that the damage makes impossible.
      const bool dated = rate.from_ || rate.until_ || rate.from_unreadable_ || rate.until_unreadable_;
      if (rate.normalized() && rate.country_ == country && dated) {
        return true;
      }
    }
    return false;
  }

  RateSelection rate_for(Country country, const Date& date) const {
    return rate_for(country, VenueKey::any(), date);
  }
};

enum class OrderSide {
  BUY,
  SELL,
};

inline constexpr std::array<OrderSide, 2> all_order_sides{OrderSide::BUY, OrderSide::SELL};
 
// The direction is closed: about forty sites in the ledger, fills, costs, risk and reconciliation read
// "not BUY" as SELL. A short-sale or short-exempt mark, or a cover-only constraint, is a separate fact that
// would travel in its own field through the intent, the request, the journal and recovery.
static_assert(
  all_order_sides.size() == 2,
  "OrderSide is buy or sell: a short-sale mark or a cover belongs in its own field, not in OrderSide"
);

enum class OrderType {
  UNKNOWN,
  LIMIT,
  MARKET,
  CONDITIONAL_LIMIT,
  BEST_LIMIT,
  PRIMARY_LIMIT,
  MID_PRICE,
  STOP_LIMIT,
  CLOSING_PRICE,
};

inline constexpr std::array<OrderType, 9> all_order_types{
  OrderType::UNKNOWN,
  OrderType::LIMIT,
  OrderType::MARKET,
  OrderType::CONDITIONAL_LIMIT,
  OrderType::BEST_LIMIT,
  OrderType::PRIMARY_LIMIT,
  OrderType::MID_PRICE,
  OrderType::STOP_LIMIT,
  OrderType::CLOSING_PRICE,
};

inline constexpr bool carries_caller_price(OrderType type) noexcept {
  switch (type) {
    case OrderType::LIMIT:
    case OrderType::CONDITIONAL_LIMIT:
    case OrderType::STOP_LIMIT:
      return true;
    case OrderType::UNKNOWN:
    case OrderType::MARKET:
    case OrderType::BEST_LIMIT:
    case OrderType::PRIMARY_LIMIT:
    case OrderType::MID_PRICE:
    case OrderType::CLOSING_PRICE:
      return false;
  }
  return false;
}

inline constexpr bool carries_trigger_price(OrderType type) noexcept {
  switch (type) {
    case OrderType::STOP_LIMIT:
      return true;
    case OrderType::UNKNOWN:
    case OrderType::LIMIT:
    case OrderType::MARKET:
    case OrderType::CONDITIONAL_LIMIT:
    case OrderType::BEST_LIMIT:
    case OrderType::PRIMARY_LIMIT:
    case OrderType::MID_PRICE:
    case OrderType::CLOSING_PRICE:
      return false;
  }
  return false;
}

enum class TimeInForce {
  UNKNOWN,
  DAY,
  IMMEDIATE_OR_CANCEL,
  FILL_OR_KILL,
};

inline constexpr std::array<TimeInForce, 4> all_times_in_force{
  TimeInForce::UNKNOWN,
  TimeInForce::DAY,
  TimeInForce::IMMEDIATE_OR_CANCEL,
  TimeInForce::FILL_OR_KILL,
};

inline constexpr bool time_in_force_expires_at_close(TimeInForce condition) noexcept {
  switch (condition) {
    case TimeInForce::DAY:
      return true;
    case TimeInForce::UNKNOWN:
    case TimeInForce::IMMEDIATE_OR_CANCEL:
    case TimeInForce::FILL_OR_KILL:
      return false;
  }
  return false;
}

enum class OrderSession {
  UNKNOWN,
  REGULAR,
  OPENING_AUCTION,
  CLOSING_AUCTION,
  PRE_MARKET,
  AFTER_HOURS,
  AFTER_HOURS_AUCTION,
  AFTER_MARKET,
  GTP,
};

inline constexpr std::array<OrderSession, 9> all_order_sessions{
  OrderSession::UNKNOWN,
  OrderSession::REGULAR,
  OrderSession::OPENING_AUCTION,
  OrderSession::CLOSING_AUCTION,
  OrderSession::PRE_MARKET,
  OrderSession::AFTER_HOURS,
  OrderSession::AFTER_HOURS_AUCTION,
  OrderSession::AFTER_MARKET,
  OrderSession::GTP,
};

enum class OrderStatus {
  UNKNOWN,
  PENDING,
  PENDING_CANCEL,
  PENDING_REPLACE,
  PARTIAL_FILLED,
  FILLED,
  CANCELED,
  REJECTED,
  CANCEL_REJECTED,
  REPLACE_REJECTED,
  REPLACED,
};

inline constexpr bool order_status_cancel_pending(OrderStatus status) noexcept {
  switch (status) {
    case OrderStatus::PENDING_CANCEL:
      return true;
    case OrderStatus::UNKNOWN:
    case OrderStatus::PENDING:
    case OrderStatus::PENDING_REPLACE:
    case OrderStatus::PARTIAL_FILLED:
    case OrderStatus::FILLED:
    case OrderStatus::CANCELED:
    case OrderStatus::REJECTED:
    case OrderStatus::CANCEL_REJECTED:
    case OrderStatus::REPLACE_REJECTED:
    case OrderStatus::REPLACED:
      return false;
  }
  return false;
}

struct OrderRequest {
  InstrumentId instrument_;
  OrderSide side_{OrderSide::BUY};
  OrderType type_{OrderType::LIMIT};
  TimeInForce time_in_force_{TimeInForce::DAY};
  OrderSession session_{OrderSession::REGULAR};
  Venue venue_{Venue::UNSPECIFIED};
  Decimal64 quantity_;
  std::optional<Decimal64> price_;
  std::optional<Decimal64> trigger_price_;
  std::optional<std::string> client_order_id_;
  bool confirm_high_value_{false};
};

struct OrderExecution {
  Decimal64 filled_quantity_;
  std::optional<Decimal64> average_filled_price_;
  std::optional<Money> filled_amount_;
  std::optional<Money> commission_;
  std::optional<Money> tax_;
  std::optional<std::chrono::system_clock::time_point> filled_at_;
  std::optional<Date> settlement_date_;
};

struct OrderSnapshot {
  std::string order_id_;
  InstrumentId instrument_;
  std::string name_;
  OrderSide side_{OrderSide::BUY};
  OrderType type_{OrderType::UNKNOWN};
  TimeInForce time_in_force_{TimeInForce::UNKNOWN};
  OrderSession session_{OrderSession::UNKNOWN};
  Venue venue_{Venue::UNSPECIFIED};
  Code<8> shape_code_;
  OrderStatus status_{OrderStatus::UNKNOWN};
  std::optional<Decimal64> price_;
  std::optional<Decimal64> trigger_price_;
  Decimal64 quantity_;
  std::optional<Decimal64> order_amount_;
  Currency currency_;
  std::optional<std::chrono::system_clock::time_point> ordered_at_;
  bool ordered_date_assumed_{false};
  std::optional<std::chrono::system_clock::time_point> canceled_at_;
  OrderExecution execution_;
};

struct OrderPage {
  std::vector<OrderSnapshot> orders_;
  std::optional<std::string> next_cursor_;
  std::chrono::system_clock::time_point received_at_;
};

struct OrderAck {
  std::string order_id_;
  std::optional<std::string> client_order_id_;
  std::chrono::system_clock::time_point accepted_at_;
};

template <typename Broker>
struct OrderRef {
  std::string primary_;
  std::string secondary_;

  static constexpr std::string_view broker() noexcept { return Broker::name; }

  std::string str() const {
    std::string text(broker());
    text += ':';
    text += primary_;
    if (!secondary_.empty()) {
      text += ':';
      text += secondary_;
    }
    return text;
  }

  friend bool operator==(const OrderRef& lhs, const OrderRef& rhs) {
    return lhs.primary_ == rhs.primary_ && lhs.secondary_ == rhs.secondary_;
  }

  friend bool operator!=(const OrderRef& lhs, const OrderRef& rhs) { return !(lhs == rhs); }
};

template <typename Broker>
struct PlacedOrder {
  OrderAck ack_;
  OrderRef<Broker> ref_;
};

struct OrderShape {
  OrderShape() = default;
  OrderShape(
    OrderType type,
    std::optional<Decimal64> price,
    std::optional<TimeInForce> time_in_force = std::nullopt,
    std::optional<OrderSession> session = std::nullopt,
    std::optional<Decimal64> trigger_price = std::nullopt
  )
  : type_(type),
    price_(std::move(price)),
    trigger_price_(std::move(trigger_price)),
    time_in_force_(time_in_force),
    session_(session) {}

  OrderType type_{OrderType::LIMIT};
  std::optional<Decimal64> price_;
  std::optional<Decimal64> trigger_price_;
  std::optional<TimeInForce> time_in_force_;
  std::optional<OrderSession> session_;
};

struct AmendInstruction {
  OrderShape shape_;
  Venue venue_{Venue::UNSPECIFIED};
  std::optional<Decimal64> quantity_;
  bool all_remaining_{false};
  bool confirm_high_value_{false};
  std::optional<OrderShape> resting_;
};

inline std::optional<Decimal64> amended_trigger_price(const AmendInstruction& instruction) {
  if (instruction.shape_.trigger_price_) {
    return instruction.shape_.trigger_price_;
  }
  if (
    carries_trigger_price(instruction.shape_.type_) && instruction.resting_ &&
    carries_trigger_price(instruction.resting_->type_)
  ) {
    return instruction.resting_->trigger_price_;
  }
  return std::nullopt;
}

template <typename Broker>
struct WorkingOrder {
  OrderSnapshot order_;
  OrderRef<Broker> ref_;
  std::optional<Decimal64> amendable_quantity_;
  bool reserved_{false};
};

template <typename Broker>
struct WorkingOrders {
  std::vector<WorkingOrder<Broker>> orders_;
  std::chrono::system_clock::time_point received_at_;
};

struct OrderHistoryQuery {
  std::optional<Date> from_;
  std::optional<Date> to_;
  std::optional<std::string> symbol_;
  std::optional<std::string> cursor_;
  std::optional<int> limit_;
};

template <typename Broker>
inline OrderShape resting_shape(const WorkingOrder<Broker>& order) {
  OrderShape shape;
  shape.type_ = order.order_.type_;
  shape.price_ = order.order_.price_;
  shape.trigger_price_ = order.order_.trigger_price_;
  shape.time_in_force_ = order.order_.time_in_force_;
  shape.session_ = order.order_.session_;
  return shape;
}

template <typename Broker>
inline AmendInstruction cancel_all(const WorkingOrder<Broker>& order) {
  AmendInstruction instruction;
  // A cancellation copies the whole shape, so a broker that re-reads it sees the same order.
  instruction.shape_.type_ = order.order_.type_;
  instruction.shape_.time_in_force_ = order.order_.time_in_force_;
  instruction.shape_.session_ = order.order_.session_;
  instruction.shape_.price_ = order.order_.price_;
  instruction.shape_.trigger_price_ = order.order_.trigger_price_;
  instruction.resting_ = instruction.shape_;
  instruction.venue_ = order.order_.venue_;
  instruction.quantity_ = order.amendable_quantity_;
  instruction.all_remaining_ = true;
  return instruction;
}

template <typename Broker>
inline AmendInstruction cancel_quantity(const WorkingOrder<Broker>& order, Decimal64 quantity) {
  AmendInstruction instruction;
  instruction.shape_.type_ = order.order_.type_;
  instruction.shape_.time_in_force_ = order.order_.time_in_force_;
  instruction.shape_.session_ = order.order_.session_;
  instruction.shape_.price_ = order.order_.price_;
  instruction.shape_.trigger_price_ = order.order_.trigger_price_;
  instruction.resting_ = instruction.shape_;
  instruction.venue_ = order.order_.venue_;
  instruction.quantity_ = quantity;
  instruction.all_remaining_ = false;
  return instruction;
}

template <typename Broker>
inline AmendInstruction replace_with(
  const WorkingOrder<Broker>& order,
  OrderShape shape,
  std::optional<Decimal64> quantity = std::nullopt
) {
  AmendInstruction instruction;
  instruction.shape_ = std::move(shape);
  instruction.resting_ = resting_shape(order);
  // The caller's shape is kept as written; `resting_` lets each adapter tell a change from a keep.
  instruction.venue_ = order.order_.venue_;
  instruction.all_remaining_ = !quantity.has_value();
  instruction.quantity_ = quantity ? quantity : order.amendable_quantity_;
  return instruction;
}

template <typename Broker>
inline AmendInstruction reprice(
  const WorkingOrder<Broker>& order,
  Decimal64 price,
  std::optional<Decimal64> quantity = std::nullopt
) {
  auto shape = resting_shape(order);
  shape.price_ = std::move(price);
  return replace_with(order, std::move(shape), std::move(quantity));
}

inline std::string format_iso8601_utc(std::chrono::system_clock::time_point value) {
  const auto seconds = std::chrono::time_point_cast<std::chrono::seconds>(value);
  const std::time_t raw = std::chrono::system_clock::to_time_t(seconds);
  std::tm utc{};
#ifdef _WIN32
  gmtime_s(&utc, &raw);
#else
  gmtime_r(&raw, &utc);
#endif
  char buffer[32];
  const auto written = std::strftime(buffer, sizeof(buffer), "%Y-%m-%dT%H:%M:%SZ", &utc);
  return std::string(buffer, written);
}

inline std::optional<std::chrono::system_clock::time_point> parse_iso8601_timestamp(
  std::string_view value
) {
  // The fixed layout first: `sscanf`'s `%d` would accept signs, spaces and short fields.
  const auto digits = [value](std::size_t from, std::size_t count) {
    for (std::size_t index = from; index < from + count; ++index) {
      if (value[index] < '0' || value[index] > '9') {
        return false;
      }
    }
    return true;
  };
  if (value.size() < 20 || !digits(0, 4) || value[4] != '-' || !digits(5, 2) || value[7] != '-' ||
      !digits(8, 2) || value[10] != 'T' || !digits(11, 2) || value[13] != ':' || !digits(14, 2) ||
      value[16] != ':' || !digits(17, 2)) {
    return std::nullopt;
  }
  int year, month, day, hour, minute, second;
  if (
    std::sscanf(
      std::string(value).c_str(), "%d-%d-%dT%d:%d:%d", &year, &month, &day, &hour, &minute, &second
    ) != 6
  ) {
    return std::nullopt;
  }
  if (!is_valid_date(Date{year, static_cast<unsigned>(month), static_cast<unsigned>(day)}) ||
      hour < 0 || hour > 23 || minute < 0 || minute > 59 || second < 0 || second > 60) {
    return std::nullopt;
  }
 
  // An optional fraction of digits only, then the zone, then nothing.
  std::size_t timezone_position = 19;
  if (value[19] == '.') {
    timezone_position = 20;
    while (timezone_position < value.size() && value[timezone_position] >= '0' &&
           value[timezone_position] <= '9') {
      ++timezone_position;
    }
    if (timezone_position == 20) {
      return std::nullopt;
    }
  }
  if (timezone_position >= value.size()) {
    return std::nullopt;
  }
  const char zone = value[timezone_position];
  if (zone == 'Z') {
    if (timezone_position + 1 != value.size()) {
      return std::nullopt;
    }
  } else if (zone == '+' || zone == '-') {
    if (value.size() != timezone_position + 6 || !digits(timezone_position + 1, 2) ||
        value[timezone_position + 3] != ':' || !digits(timezone_position + 4, 2)) {
      return std::nullopt;
    }
  } else {
    return std::nullopt;
  }
 
  std::tm time{};
  time.tm_year = year - 1900;
  time.tm_mon = month - 1;
  time.tm_mday = day;
  time.tm_hour = hour;
  time.tm_min = minute;
  time.tm_sec = second;
  time.tm_isdst = 0;
#ifdef _WIN32
  std::time_t utc = _mkgmtime(&time);
#else
  std::time_t utc = timegm(&time);
#endif
  if (utc == static_cast<std::time_t>(-1)) {
    return std::nullopt;
  }
 
  if (value[timezone_position] != 'Z') {
    int offset_hour, offset_minute;
    if (
      std::sscanf(
        std::string(value.substr(timezone_position + 1)).c_str(),
        "%d:%d",
        &offset_hour,
        &offset_minute
      ) != 2
    ) {
      return std::nullopt;
    }
    if (offset_hour > 23 || offset_minute > 59) {
      return std::nullopt;
    }
    const int offset = offset_hour * 3600 + offset_minute * 60;
    utc += value[timezone_position] == '+' ? -offset : offset;
  }
 
  auto result = std::chrono::system_clock::from_time_t(utc);
  const auto dot = value.find('.', 19);
  if (dot != std::string_view::npos && dot < timezone_position) {
    std::uint32_t milliseconds = 0;
    std::uint32_t factor = 100;
    for (std::size_t index = dot + 1; index < timezone_position && factor > 0; ++index) {
      if (value[index] < '0' || value[index] > '9') {
        return std::nullopt;
      }
      milliseconds += static_cast<std::uint32_t>(value[index] - '0') * factor;
      factor /= 10;
    }
    result += std::chrono::milliseconds(milliseconds);
  }
  return result;
}
 
} // namespace algotradelib
 
namespace std {

template <typename Broker>
struct hash<algotradelib::OrderRef<Broker>> {
  std::size_t operator()(const algotradelib::OrderRef<Broker>& ref) const noexcept {
    std::size_t seed = hash<std::string>{}(ref.primary_);
    seed ^= hash<std::string>{}(ref.secondary_) + 0x9e3779b97f4a7c15ULL + (seed << 6) + (seed >> 2);
    return seed;
  }
};
 
} // namespace std