instrument.hpp

#pragma once
 
#include "./types.hpp"
 
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
 
namespace algotradelib {

struct MarketSegment {
  enum class Known {
    UNKNOWN,
    KOSPI,
    KOSDAQ,
    NYSE,
    NASDAQ,
    AMEX,
  };

  Known known_{Known::UNKNOWN};
  Code<12> other_;

  std::string str() const {
    switch (known_) {
      case Known::KOSPI:
        return "KOSPI";
      case Known::KOSDAQ:
        return "KOSDAQ";
      case Known::NYSE:
        return "NYSE";
      case Known::NASDAQ:
        return "NASDAQ";
      case Known::AMEX:
        return "AMEX";
      case Known::UNKNOWN:
        break;
    }
    return other_.empty() ? std::string("UNKNOWN") : other_.str();
  }

  friend bool operator==(const MarketSegment& lhs, const MarketSegment& rhs) {
    return lhs.known_ == rhs.known_ && lhs.other_ == rhs.other_;
  }

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

inline MarketSegment market_segment(std::string_view code) {
  MarketSegment segment;
  if (code == "KOSPI") {
    segment.known_ = MarketSegment::Known::KOSPI;
  } else if (code == "KOSDAQ") {
    segment.known_ = MarketSegment::Known::KOSDAQ;
  } else if (code == "NYSE") {
    segment.known_ = MarketSegment::Known::NYSE;
  } else if (code == "NASDAQ") {
    segment.known_ = MarketSegment::Known::NASDAQ;
  } else if (code == "AMEX") {
    segment.known_ = MarketSegment::Known::AMEX;
  } else if (const auto preserved = Code<12>::try_make(code)) {
    segment.other_ = *preserved;
  }
  return segment;
}

enum class SecurityType {
  UNKNOWN,
  STOCK,
  FOREIGN_STOCK,
  DEPOSITARY_RECEIPT,
  INFRASTRUCTURE_FUND,
  REIT,
  ETF,
  FOREIGN_ETF,
  ETN,
  STOCK_WARRANT,
};

enum class InstrumentStatus {
  UNKNOWN,
  SCHEDULED,
  ACTIVE,
  DELISTED,
};

struct TickBand {
  Decimal64 from_;
  Decimal64 tick_;
};

struct PriceRule {
  enum class Kind {
    STATED,
    UNCONSTRAINED,
    UNKNOWN,
  };

  Kind kind_{Kind::UNKNOWN};
  std::vector<TickBand> bands_;
  std::string source_;

  constexpr bool grid_known() const noexcept {
    switch (kind_) {
      case Kind::STATED:
      case Kind::UNCONSTRAINED:
        return true;
      case Kind::UNKNOWN:
        return false;
    }
    return false;
  }

  std::optional<Decimal64> tick_at(const Decimal64& price) const {
    std::optional<Decimal64> tick;
    for (const auto& band : bands_) {
      if (decimal_less(price, band.from_)) {
        break;
      }
      tick = band.tick_;
    }
    return tick;
  }

  std::optional<bool> on_tick(const Decimal64& price) const {
    if (!grid_known()) {
      return std::nullopt;
    }
    const auto tick = tick_at(price);
    if (!tick) {
      return true;
    }
    const auto rest = remainder(price, *tick);
    if (!rest) {
      return std::nullopt;
    }
    return rest->coefficient() == 0;
  }

  std::optional<Decimal64> round_to_tick(const Decimal64& price, OrderSide side) const {
    if (!grid_known()) {
      return std::nullopt;
    }
    const auto tick = tick_at(price);
    if (!tick) {
      return price;
    }
    const auto rest = remainder(price, *tick);
    if (!rest) {
      return std::nullopt;
    }
    if (rest->coefficient() == 0) {
      return decimal_normalized(price);
    }
    const auto floor_price = decimal_subtract(price, *rest);
    if (!floor_price) {
      return std::nullopt;
    }
    if (side == OrderSide::BUY) {
      return floor_price;
    }
    return decimal_add(*floor_price, *tick);
  }

  static PriceRule krx_equity() {
    PriceRule rule;
    rule.kind_ = Kind::STATED;
    rule.source_ = "KRX cash equity tick table, 2023-01 revision (library-maintained)";
    rule.bands_ = {
      TickBand{Decimal64::parse("0"), Decimal64::parse("1")},
      TickBand{Decimal64::parse("2000"), Decimal64::parse("5")},
      TickBand{Decimal64::parse("5000"), Decimal64::parse("10")},
      TickBand{Decimal64::parse("20000"), Decimal64::parse("50")},
      TickBand{Decimal64::parse("50000"), Decimal64::parse("100")},
      TickBand{Decimal64::parse("200000"), Decimal64::parse("500")},
      TickBand{Decimal64::parse("500000"), Decimal64::parse("1000")},
    };
    return rule;
  }

  static PriceRule unconstrained() {
    PriceRule rule;
    rule.kind_ = Kind::UNCONSTRAINED;
    rule.source_ = "no exchange price grid";
    return rule;
  }

  static PriceRule unknown(std::string reason) {
    PriceRule rule;
    rule.kind_ = Kind::UNKNOWN;
    rule.source_ = std::move(reason);
    return rule;
  }
 
private:
  // `price` modulo `tick`, exactly.
  static std::optional<Decimal64> remainder(const Decimal64& price, const Decimal64& tick) {
    std::int64_t left = 0;
    std::int64_t right = 0;
    std::uint8_t scale = 0;
    if (!decimal_detail::align(price, tick, left, right, scale) || right == 0) {
      return std::nullopt;
    }
    auto rest = left % right;
    if (rest < 0) {
      rest += right < 0 ? -right : right;
    }
    return Decimal64(rest, scale);
  }
};

inline PriceRule price_rule_for(Country country, SecurityType type) {
  switch (country) {
    case Country::US:
      return PriceRule::unconstrained();
    case Country::KR:
      break;
  }
  if (country != Country::KR) {
    // Not a `Country` (a cast): no grid is known.
    return PriceRule::unknown("no price grid is known for this market");
  }
  switch (type) {
    case SecurityType::STOCK:
    case SecurityType::FOREIGN_STOCK:
    case SecurityType::DEPOSITARY_RECEIPT:
    case SecurityType::INFRASTRUCTURE_FUND:
    case SecurityType::REIT:
      return PriceRule::krx_equity();
    case SecurityType::ETF:
    case SecurityType::FOREIGN_ETF:
    case SecurityType::ETN:
      return PriceRule::unknown(
        "KRX prices funds and notes on a ladder this library does not carry"
      );
    case SecurityType::STOCK_WARRANT:
    case SecurityType::UNKNOWN:
      break;
  }
  return PriceRule::unknown("no price grid is known for this security type");
}

class StatedDate {
public:
  enum class State {
    NOT_STATED,
    STATED,
    UNREADABLE,
  };

  StatedDate() = default;

  static StatedDate stated(Date date) {
    StatedDate result;
    result.state_ = State::STATED;
    result.date_ = date;
    return result;
  }

  static StatedDate unreadable() {
    StatedDate result;
    result.state_ = State::UNREADABLE;
    return result;
  }

  State state() const noexcept { return state_; }

  const Date& date() const {
    if (state_ != State::STATED) {
      throw std::logic_error("StatedDate::date() read a date that was not stated");
    }
    return date_;
  }

  friend bool operator==(const StatedDate& lhs, const StatedDate& rhs) {
    return lhs.state_ == rhs.state_ && (lhs.state_ != State::STATED || lhs.date_ == rhs.date_);
  }

  friend bool operator!=(const StatedDate& lhs, const StatedDate& rhs) { return !(lhs == rhs); }
 
private:
  State state_{State::NOT_STATED};
  Date date_{};
};

enum class DateExclusion {
  EXCLUDED,
  NOT_EXCLUDED,
  UNREADABLE,
};

struct Instrument {
  InstrumentId id_;
  std::string name_;
  std::string english_name_;
  std::string isin_;
  MarketSegment segment_;
  SecurityType type_{SecurityType::UNKNOWN};
  InstrumentStatus status_{InstrumentStatus::UNKNOWN};
  Currency currency_;
  bool common_share_{true};
  StatedDate listed_on_;
  StatedDate delisted_on_;
  std::optional<Decimal64> shares_outstanding_;
  std::optional<Decimal64> lot_size_;
  PriceRule price_rule_;

  DateExclusion dates_exclude(Date day) const {
    using State = StatedDate::State;
    if (listed_on_.state() == State::STATED && day < listed_on_.date()) {
      return DateExclusion::EXCLUDED;
    }
    if (delisted_on_.state() == State::STATED && !(day < delisted_on_.date())) {
      return DateExclusion::EXCLUDED;
    }
    if (leaves_exclusion_unknown(listed_on_.state()) || leaves_exclusion_unknown(delisted_on_.state())) {
      return DateExclusion::UNREADABLE;
    }
    return DateExclusion::NOT_EXCLUDED;
  }
 
private:
  // Whether a date in this state could rule a day out without saying so: only an unreadable one.
  static constexpr bool leaves_exclusion_unknown(StatedDate::State state) noexcept {
    switch (state) {
      case StatedDate::State::UNREADABLE:
        return true;
      case StatedDate::State::NOT_STATED:
      case StatedDate::State::STATED:
        return false;
    }
    return true;
  }
};
 
} // namespace algotradelib