futu_cache/qot_cache/

order_book_merge.rs

use std::collections::HashMap;

use super::{CachedOrderBook, CachedOrderBookDetail, CachedOrderBookLevel};

// =============================================================================
// v1.4.110 codex QOT Phase 4 Slice 7: MergeMultipleOrderBookCaches pure fn.
//
// 对齐 C++ `QotRealTimeData::MergeMultipleOrderBookCaches` + `MergeOrderBookLists`
// (QotRealTimeData.cpp:1440-1591):
//
// 1. **Per-side price-key merge** — 每档按 `price * 1e9` 取整作 key, 同 key
//    累加 volume / order_count / detail_list (C++ MergedGear struct).
// 2. **Side-aware sort** — bid 降序 (高价先), ask 升序 (低价先).
// 3. **Top N truncate** — 仅当 `max_depth > 0` 时截断 (crypto LV2 用 40).
// 4. **Timestamp**: bid/ask 各自取多 source 的最大 timestamp.
// 5. **Skip price ≤ 0**: C++ "过滤空数据占位条目" (line 1466).
// =============================================================================

/// Per-side merge buffer (对齐 C++ `MergedGear`).
#[derive(Debug, Clone)]
struct MergedGear {
    price: f64,
    volume: i64,
    order_count: i32,
    detail_list: Vec<CachedOrderBookDetail>,
    /// v1.4.110 codex audit Round4 R4-4: 高精度量累加器. 对齐 C++
    /// `gear.dVolume += has_hpvolume() ? hpvolume() : volume()` —— 累加 de-scale
    /// 后的真实量 (有 hp_volume 用之, 否则 fallback `volume`).
    hp_volume: f64,
}

/// Per-side merge: take multiple lists, aggregate by price key, sort, optionally
/// truncate to `max_depth`. 不会修改输入.
///
/// `is_bid=true` → sort 降序; `false` → 升序.
fn merge_order_book_side(
    sources: &[&[CachedOrderBookLevel]],
    is_bid: bool,
    max_depth: usize,
) -> Vec<CachedOrderBookLevel> {
    if sources.is_empty() {
        return vec![];
    }
    // 价格精度放大到整数 (9 位小数, 对齐 C++ `PriceToKey`).
    fn price_to_key(p: f64) -> i64 {
        (p * 1e9 + 0.5) as i64
    }

    let mut merged: HashMap<i64, MergedGear> = HashMap::new();
    for list in sources {
        for level in list.iter() {
            // C++: 过滤空数据占位条目 (price <= 0).
            if level.price <= 0.0 {
                continue;
            }
            let key = price_to_key(level.price);
            let entry = merged.entry(key).or_insert(MergedGear {
                price: level.price,
                volume: 0,
                order_count: 0,
                detail_list: vec![],
                hp_volume: 0.0,
            });
            entry.volume = entry.volume.saturating_add(level.volume);
            entry.order_count = entry.order_count.saturating_add(level.order_count);
            entry.detail_list.extend(level.detail_list.iter().cloned());
            // v1.4.110 codex audit Round4 R4-4: 对齐 C++ merge gear.dVolume 累加 ——
            // 有 hp_volume 用真实小数量, 否则 fallback `volume`.
            entry.hp_volume += level.hp_volume.unwrap_or(level.volume as f64);
        }
    }

    let mut keys: Vec<i64> = merged.keys().copied().collect();
    if is_bid {
        // 买盘: 价格从高到低 (降序).
        keys.sort_by(|a, b| b.cmp(a));
    } else {
        // 卖盘: 价格从低到高 (升序).
        keys.sort();
    }

    let mut out: Vec<CachedOrderBookLevel> = keys
        .iter()
        .map(|k| {
            let g = &merged[k];
            CachedOrderBookLevel {
                price: g.price,
                volume: g.volume,
                order_count: g.order_count,
                detail_list: g.detail_list.clone(),
                // v1.4.110 codex audit Round4 R4-4: merge 输出 crypto 多交易所
                // 合单盘口, 始终带累加后的 hp_volume (对齐 C++ set_hpvolume).
                hp_volume: Some(g.hp_volume),
            }
        })
        .collect();

    // 深度截断: max_depth > 0 时生效.
    if max_depth > 0 && out.len() > max_depth {
        out.truncate(max_depth);
    }
    out
}

/// Merge N exchange-level orderbook caches into one broker-level cache.
///
/// 对齐 C++ `QotRealTimeData::MergeMultipleOrderBookCaches(vSources, pbMerged,
/// nMaxDepth=40)` (QotRealTimeData.cpp:1534-1591):
/// - 第一个 source 作为基础 (拷 svr_recv_time 等基本字段, 但 bid/ask list 重算)
/// - 按 price key 聚合 bid/ask, 同 price 累加 volume + order_count + detail
/// - bid 高价优先, ask 低价优先, 截断到 `max_depth`
/// - bid/ask timestamp 取多 source 最大值
///
/// `max_depth = 0` → 不截断 (C++ 行为, line 1579-1583 `if nMaxDepth > 0`).
/// `max_depth = 40` → crypto LV2 broker-level cache 用 (line 1014).
pub fn merge_multiple_order_book_caches(
    sources: &[CachedOrderBook],
    max_depth: usize,
) -> CachedOrderBook {
    if sources.is_empty() {
        return CachedOrderBook::default();
    }

    // v1.4.110 codex audit Round2 P2 #17: 收 slice-of-slice 而非 deep clone.
    // merge_order_book_side 只读 levels (price/volume/order_count/detail_list),
    // 不消费 Vec — 之前 `.bid_list.clone()` 每 source deep clone N×M levels
    // (5 exchange × 40 level = 200 clone per LV2 push), crypto LV2 push 1Hz+
    // 频率下浪费. 改 `.as_slice()` 只收引用, 零 Level clone.
    let bid_sources: Vec<&[CachedOrderBookLevel]> =
        sources.iter().map(|s| s.bid_list.as_slice()).collect();
    let ask_sources: Vec<&[CachedOrderBookLevel]> =
        sources.iter().map(|s| s.ask_list.as_slice()).collect();

    let bid_merged = merge_order_book_side(&bid_sources, true, max_depth);
    let ask_merged = merge_order_book_side(&ask_sources, false, max_depth);

    // Timestamp 取所有 source 最大 (对齐 C++ line 1572-1575).
    let max_bid_ts = sources
        .iter()
        .filter_map(|s| s.svr_recv_time_bid_timestamp)
        .fold(None::<f64>, |acc, t| {
            Some(acc.map(|a| a.max(t)).unwrap_or(t))
        });
    let max_ask_ts = sources
        .iter()
        .filter_map(|s| s.svr_recv_time_ask_timestamp)
        .fold(None::<f64>, |acc, t| {
            Some(acc.map(|a| a.max(t)).unwrap_or(t))
        });

    CachedOrderBook {
        bid_list: bid_merged,
        ask_list: ask_merged,
        svr_recv_time_bid: None,
        svr_recv_time_bid_timestamp: max_bid_ts,
        svr_recv_time_ask: None,
        svr_recv_time_ask_timestamp: max_ask_ts,
    }
}