order_updates.hpp

#pragma once
 
#include <algorithm>
#include <cstddef>
#include <optional>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "../core/types.hpp"
 
namespace algotradelib {
namespace runner {
 
namespace order_update_detail {

inline bool same_number(const Decimal64& lhs, const Decimal64& rhs) {
  return !decimal_less(lhs, rhs) && !decimal_less(rhs, lhs);
}

inline bool same_number(
  const std::optional<Decimal64>& lhs, const std::optional<Decimal64>& rhs
) {
  if (lhs.has_value() != rhs.has_value()) {
    return false;
  }
  return !lhs.has_value() || same_number(*lhs, *rhs);
}

inline bool same_observable_state(const OrderSnapshot& lhs, const OrderSnapshot& rhs) {
  return lhs.status_ == rhs.status_ &&
    same_number(lhs.execution_.filled_quantity_, rhs.execution_.filled_quantity_) &&
    same_number(lhs.price_, rhs.price_) &&
    same_number(lhs.trigger_price_, rhs.trigger_price_) &&
    same_number(lhs.quantity_, rhs.quantity_) &&
    same_number(lhs.order_amount_, rhs.order_amount_) &&
    lhs.canceled_at_ == rhs.canceled_at_;
}
 
} // namespace order_update_detail

template <typename Broker>
class OrderUpdateWatch {
public:
  std::vector<OrderSnapshot> changed(const std::vector<WorkingOrder<Broker>>& rows) {
    return observe(rows, /*report=*/true);
  }

  void adopt(const std::vector<WorkingOrder<Broker>>& rows) {
    observe(rows, /*report=*/false);
  }

  std::size_t untracked_rows() const noexcept { return untracked_; }

  std::size_t tracked_orders() const noexcept { return tracked_.size(); }

  std::size_t contradicted_rows() const noexcept { return contradicted_; }
 
private:
  // One order's last observed state, against which the next listing is compared.
  struct Tracked {
    OrderRef<Broker> ref_;
    OrderSnapshot last_;
    // Set when this listing stated the same order twice and the two readings disagreed.
    bool contradicted_{false};
  };
 
  // Runs one observation, reporting differences or silently adopting them.
  //
  // Two passes, and the split is what keeps the duplicate rule honest. The first reduces the
  // listing to one entry per reference; only then does the second decide what changed, so a
  // contradiction found on the listing's last row still suppresses a report the first row would
  // otherwise have earned.
  std::vector<OrderSnapshot> observe(
    const std::vector<WorkingOrder<Broker>>& rows, bool report
  ) {
    std::vector<Tracked> next;
    next.reserve(rows.size());
    // Where each reference sits, in this listing (`next`) and in the previous one (`tracked_`), so a
    // long listing is read once and not once per row. Both are looked up and never iterated: the
    // order of `next`, and so of the updates, is the listing's. Built here from the vectors each
    // time, so nothing has to be kept in step with `tracked_`; a reference maps to the first entry
    // that has it, which is the one a scan would find.
    std::unordered_map<OrderRef<Broker>, std::size_t> built;
    built.reserve(rows.size());
    std::unordered_map<OrderRef<Broker>, std::size_t> held_at;
    held_at.reserve(tracked_.size());
    for (std::size_t at = 0; at < tracked_.size(); ++at) {
      held_at.emplace(tracked_[at].ref_, at);
    }
 
    for (const auto& row : rows) {
      // This library's own arithmetic rather than something a broker stated, and the contract is
      // about what a broker stated. Neither caller passes one today.
      if (row.reserved_) {
        continue;
      }
      if (row.ref_.primary_.empty() && row.ref_.secondary_.empty()) {
        ++untracked_;
        continue;
      }
      const auto [at, first] = built.try_emplace(row.ref_, next.size());
      if (first) {
        next.push_back(Tracked{row.ref_, row.order_, false});
        continue;
      }
      // One reference, one entry: a duplicated row must not become two events (and two orders).
      auto& already = next[at->second];
      if (!order_update_detail::same_observable_state(already.last_, row.order_)) {
        // Two readings that disagree: report neither, and count it.
        already.contradicted_ = true;
      }
    }
 
    std::vector<OrderSnapshot> updates;
    for (const auto& entry : next) {
      if (entry.contradicted_) {
        ++contradicted_;
        continue;
      }
      const auto found = held_at.find(entry.ref_);
      const Tracked* held = found == held_at.end() ? nullptr : &tracked_[found->second];
      const bool differs =
        held == nullptr || !order_update_detail::same_observable_state(held->last_, entry.last_);
      if (report && differs) {
        updates.push_back(entry.last_);
      }
    }
 
    // A contradicted order keeps no baseline, because there is no reading of it this listing could
    // settle on. The next listing that states it once reports it afresh.
    next.erase(
      std::remove_if(
        next.begin(),
        next.end(),
        [](const Tracked& entry) { return entry.contradicted_; }
      ),
      next.end()
    );
    tracked_ = std::move(next);
    return updates;
  }
 
  std::vector<Tracked> tracked_;
  std::size_t untracked_{0};
  std::size_t contradicted_{0};
};
 
} // namespace runner
} // namespace algotradelib