config.hpp

#pragma once
 
#include "../../network/oauth.hpp"
 
#include "../../core/types.hpp"
 
#include <boost/json.hpp>
 
#include <chrono>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <iterator>
#include <stdexcept>
#include <string>
#include <string_view>
 
namespace algotradelib {
namespace kiwoom {
 
// https://openapi.kiwoom.com/guide/apiguide
// Token issue:  au10001  POST https://api.kiwoom.com/oauth2/token
// Token revoke: au10002  POST https://api.kiwoom.com/oauth2/revoke
struct KiwoomConfig;
struct KiwoomRest;

enum class MarketTape {
  CONSOLIDATED,
  KRX,
  NXT,
};

inline constexpr const char* tape_suffix(MarketTape tape) noexcept {
  switch (tape) {
    case MarketTape::KRX:
      return "";
    case MarketTape::NXT:
      return "_NX";
    case MarketTape::CONSOLIDATED:
      return "_AL";
  }
  return "_AL";
}

inline std::chrono::system_clock::time_point parse_compact_expiry(std::string_view text) {
  if (text.size() != 14) {
    return {};
  }
  for (const char digit : text) {
    if (digit < '0' || digit > '9') {
      return {};
    }
  }
  const auto number = [text](std::size_t offset, std::size_t length) {
    int value = 0;
    for (std::size_t index = offset; index < offset + length; ++index) {
      value = value * 10 + (text[index] - '0');
    }
    return value;
  };
  std::tm parts{};
  parts.tm_year = number(0, 4) - 1900;
  parts.tm_mon = number(4, 2) - 1;
  parts.tm_mday = number(6, 2);
  parts.tm_hour = number(8, 2);
  parts.tm_min = number(10, 2);
  parts.tm_sec = number(12, 2);
  parts.tm_isdst = 0;
#ifdef _WIN32
  const std::time_t utc = _mkgmtime(&parts) - 9 * 3600;
#else
  const std::time_t utc = timegm(&parts) - 9 * 3600;
#endif
  return std::chrono::system_clock::from_time_t(utc);
}

enum class KiwoomPositionScope {
  UNSPECIFIED,
  VALUATION_ONLY,
};

inline constexpr bool kiwoom_position_scope_asserted(KiwoomPositionScope scope) noexcept {
  switch (scope) {
    case KiwoomPositionScope::UNSPECIFIED:
      return false;
    case KiwoomPositionScope::VALUATION_ONLY:
      return true;
  }
  return false;
}

enum class KiwoomSellableScope {
  UNSPECIFIED,
  WHOLE_HOLDING,
};

struct KiwoomConfig : public network::ClientCredentials<KiwoomConfig> {
  bool is_demo_ = true;

  MarketTape market_tape_ = MarketTape::CONSOLIDATED;

  Venue holdings_venue_ = Venue::UNSPECIFIED;

  KiwoomPositionScope holdings_position_scope_ = KiwoomPositionScope::UNSPECIFIED;

  KiwoomSellableScope holdings_sellable_scope_ = KiwoomSellableScope::UNSPECIFIED;

  void from_env_impl() {
    const char* key = std::getenv("KIWOOM_APP_KEY");
    const char* secret = std::getenv("KIWOOM_SECRET_KEY");
    if (!key || !secret) {
      throw std::runtime_error("Add KIWOOM_APP_KEY and KIWOOM_SECRET_KEY environment variables.");
    }
    // Read before anything is assigned, so a refused load leaves this config as it was.
    const bool demo = demo_from_env();
    key_ = key;
    secret_ = secret;
    is_demo_ = demo;
  }

  void from_json_impl(const std::string& filename) {
    std::ifstream ifs(filename);
    if (!ifs.is_open()) {
      throw std::runtime_error("Cannot open Kiwoom credential file: " + filename);
    }
    const std::string content(
      std::istreambuf_iterator<char>(ifs), std::istreambuf_iterator<char>{}
    );
    boost::system::error_code ec;
    const auto jv = json::parse(content, ec);
    if (ec || !jv.is_object()) {
      throw std::runtime_error(
        "Failed to parse Kiwoom credentials file: " + filename +
        (ec ? " — " + ec.message() : std::string(" — not a JSON object"))
      );
    }
    const auto& doc = jv.as_object();
    const json::value* key = doc.if_contains("appkey");
    const json::value* secret = doc.if_contains("secretkey");
    if (!key || !secret || !key->is_string() || !secret->is_string()) {
      throw std::runtime_error("Credential file should contain appkey and secretkey as strings");
    }
    // Everything is read and checked before anything is assigned, so a refused file leaves this
    // config -- and the endpoint it already selected -- exactly as it was.
    const bool demo = demo_from_json(doc, filename);
    key_ = key->get_string().c_str();
    secret_ = secret->get_string().c_str();
    is_demo_ = demo;
  }

  static bool demo_from_env() {
    const char* demo = std::getenv("KIWOOM_DEMO");
    if (!demo || std::string_view(demo) == "1") {
      return true;
    }
    if (std::string_view(demo) == "0") {
      return false;
    }
    throw std::runtime_error(
      std::string("KIWOOM_DEMO is \"") + demo + "\"; set it to 1 for the demo endpoints or 0 to trade "
      "live, or leave it unset for demo."
    );
  }

  static bool demo_from_json(const json::object& doc, const std::string& filename) {
    const json::value* demo = doc.if_contains("demo");
    if (!demo) {
      return true;
    }
    if (!demo->is_bool()) {
      throw std::runtime_error(
        "Kiwoom credential file " + filename + " has a \"demo\" that is not true or false; write "
        "true for the demo endpoints or false to trade live, or leave it out for demo."
      );
    }
    return demo->get_bool();
  }

  static constexpr std::string_view key_field() noexcept { return "appkey"; }

  static constexpr std::string_view secret_field() noexcept { return "secretkey"; }

  const char* rest_host() const noexcept {
    return is_demo_ ? "mockapi.kiwoom.com" : "api.kiwoom.com";
  }

  const char* rest_port() const noexcept { return "443"; }

  const char* ws_host() const noexcept {
    return is_demo_ ? "mockapi.kiwoom.com" : "api.kiwoom.com";
  }

  const char* ws_port() const noexcept { return "10000"; }

  std::string tape_symbol(std::string_view symbol) const {
    return std::string(symbol) + tape_suffix(market_tape_);
  }
};

struct KiwoomRest : public network::AuthBody<KiwoomRest> {
  std::string token_type_;

  static constexpr std::string_view token_field() noexcept { return "token"; }

  void from_json_impl(const json::object& doc) {
    if (const auto expiry = doc.if_contains("expires_dt"); expiry && expiry->is_string()) {
      expires_at_ = parse_compact_expiry(std::string_view(expiry->as_string()));
    }
    if (const auto type = doc.if_contains("token_type"); type && type->is_string()) {
      token_type_ = type->as_string().c_str();
    }
  }
};
 
} // namespace kiwoom
} // namespace algotradelib