portfolio.hpp

#pragma once
 
#include <algotradelib/core>
 
#include <chrono>
#include <optional>
#include <vector>
 
namespace algotradelib {
namespace strategy {

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

template <typename Broker>
struct Portfolio {
  std::vector<HoldingPosition> positions_;
  std::vector<Money> cash_;
  std::vector<BuyingPower> buying_power_;
  std::vector<WorkingOrder<Broker>> working_;
  std::chrono::system_clock::time_point as_of_{};
  std::chrono::system_clock::time_point working_as_of_{};

  bool listing_newer_than_holdings() const noexcept {
    const std::chrono::system_clock::time_point epoch{};
    return as_of_ != epoch && working_as_of_ != epoch && working_as_of_ > as_of_;
  }

  SellableBasis sellable_basis_;

  std::optional<Decimal64> quantity_of(const InstrumentId& instrument) const {
    for (const auto& position : positions_) {
      if (position.instrument_ == instrument) {
        return position.quantity_;
      }
    }
    return std::nullopt;
  }

  std::optional<Decimal64> net_quantity_of(const InstrumentId& instrument) const {
    auto total = Decimal64::parse("0");
    for (const auto& position : positions_) {
      if (!(position.instrument_ == instrument)) {
        continue;
      }
      const auto sum = decimal_add(total, position.quantity_);
      if (!sum) {
        return std::nullopt;
      }
      total = *sum;
    }
    return total;
  }

  Decimal64 working_quantity(const InstrumentId& instrument, OrderSide side) const {
    Decimal64 total = Decimal64::parse("0");
    for (const auto& order : working_) {
      if (!(order.order_.instrument_ == instrument) || order.order_.side_ != side) {
        continue;
      }
      if (!order_is_open(order.order_.status_)) {
        continue;
      }
      const auto remaining = decimal_subtract(
        order.order_.quantity_, order.order_.execution_.filled_quantity_
      );
      if (!remaining || decimal_less(*remaining, Decimal64::parse("0"))) {
        continue;
      }
      const auto sum = decimal_add(total, *remaining);
      if (!sum) {
        continue;
      }
      total = *sum;
    }
    return total;
  }
 
 public:
  struct SellableReading {
    std::optional<Decimal64> quantity_;
    SellableBasis basis_;
  };

  SellableReading sellable_reading_for(const InstrumentId& instrument) const {
    SellableReading reading;
    bool seen = false;
    for (const auto& position : positions_) {
      if (!(position.instrument_ == instrument)) {
        continue;
      }
      const SellableBasis basis =
        position.sellable_basis_ ? *position.sellable_basis_ : sellable_basis_;
      if (!seen) {
        reading.quantity_ = position.sellable_quantity_;
        reading.basis_ = basis;
        seen = true;
        continue;
      }
      // A second row of the same instrument. Figures are never summed, and a disagreement makes even
      // the first row's figure uninterpretable, since nothing says which lot a sale draws from.
      // First, a basis that disagrees.
      if (basis.coverage_ != reading.basis_.coverage_ ||
          basis.resting_ != reading.basis_.resting_) {
        return SellableReading{reading.quantity_, SellableBasis{}};
      }
      // Then figures that disagree under one basis: two rows claiming the limit for the same shares
      // with different numbers contradict each other. (KIS pages can repeat a `pdno`.)
      // Compared as numbers: `operator==` also compares the scale, and "70" beside "70.0" is one figure.
      if (reading.quantity_ && position.sellable_quantity_ &&
          (decimal_less(*position.sellable_quantity_, *reading.quantity_) ||
           decimal_less(*reading.quantity_, *position.sellable_quantity_))) {
        return SellableReading{reading.quantity_, SellableBasis{}};
      }
      // A later row's figure where the first had none is the only figure stated.
      if (!reading.quantity_) {
        reading.quantity_ = position.sellable_quantity_;
      }
    }
    return reading;
  }

  std::optional<Decimal64> cash_in(const Currency& currency) const {
    for (const auto& amount : cash_) {
      if (amount.currency_ == currency) {
        return amount.amount_;
      }
    }
    return std::nullopt;
  }

  std::optional<Decimal64> buying_power_in(const Currency& currency) const {
    for (const auto& amount : buying_power_) {
      if (amount.cash_.currency_ == currency) {
        return amount.cash_.amount_;
      }
    }
    return std::nullopt;
  }

  std::optional<Decimal64> sellable_quantity_of(const InstrumentId& instrument) const {
    for (const auto& position : positions_) {
      if (position.instrument_ == instrument) {
        return position.sellable_quantity_;
      }
    }
    return std::nullopt;
  }

  const WorkingOrder<Broker>* find_working(const OrderRef<Broker>& ref) const {
    for (const auto& order : working_) {
      if (order.ref_ == ref) {
        return &order;
      }
    }
    return nullptr;
  }
 
};
 
} // namespace strategy
} // namespace algotradelib