futu_backend/

stock_list.rs

// 股票列表同步
//
// 对应 C++ SecListDBUpdater
// CMD 6746: 增量拉取股票列表 (响应 zlib 压缩)
// CMD 6822: 注册市场事件推送 (需要 header reserved 设置市场类型)
// CMD 6823: 拉取市场状态

use std::io::Read as IoRead;

use flate2::read::GzDecoder;
use futu_core::error::{FutuError, Result};

use crate::conn::BackendConn;
use crate::proto_internal::{ft_cmd6822, ft_cmd6823, stock_list_sync_svr};

/// 股票列表同步命令 ID
pub const CMD_UPDATE_SEC_LIST: u16 = 6746;
/// 注册市场事件推送
pub const CMD_EVENT_NOTICE_SUB: u16 = 6822;
/// 拉取市场状态
pub const CMD_PULL_EVENT_NOTICE: u16 = 6823;

/// 行情市场类型 (C++ NN_QuoteMktType + v1.4.49 扩展)
///
/// 作 CMD 6822/6823 TCP header reserved[0] 时必须先经
/// `quote_mkt_to_nn_mkt_type` 转成 C++ `NN_QuoteMktType`。
///
/// 其中 `DigitalCcy` 虽然是 v1.4.49 扩展进来的 market-id 分组，但线上
/// C++ 10.5.6508 已有 `NN_QuoteMktType_CRYPTO = 17`，不能再当成
/// "只用于过滤、不发 backend" 的本地分组。
#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[non_exhaustive]
pub enum QuoteMktType {
    Unknown = 0,
    HK = 1,
    US = 2,
    SH = 3,
    SZ = 4,
    HKFuture = 5,
    HKFuture2 = 6,
    USOption = 7,
    USFuture = 8,
    HKOption = 9,
    SHKC = 10,
    Forex = 11,
    SGFuture = 12,
    JPFuture = 13,
    // v1.4.49 新增：仅用于 MarketID 范围过滤，不作 TCP header
    Bond = 14,          // 130-159 债券
    GlobalIndex = 15,   // 260-359 全球指数
    SGSecurity = 16,    // 180-184 新加坡股票
    StockConnect = 17,  // 50-51 港股通/A股通
    DigitalCcy = 18,    // 360-459 数字货币
    TreasuryYield = 19, // 460-559 国债收益率
    // v1.4.50 新增：仅用于 MarketID 范围过滤，不作 TCP header
    Fund = 20, // 560-569 基金市场 (C++ NN_QuoteMktID_FUND_*)
}

/// v1.4.68 修正（eli v1.4.57 #5 P2 修）：CMD 6822/6823 reserved[0] 实际接受
/// `NN_QuoteMktType` 值（C++ enum），**不是 `QotCommon.QotMarket` 值**。
///
/// C++ 实锤对照 `NNBiz_Qot_EventNotice.cpp::SubEventNotice(enMktType)` L178-188：
/// CMD 6822 订阅请求 reserved[0] = NN_QuoteMktType 枚举值：
/// - NN_QuoteMktType_HK = 1
/// - NN_QuoteMktType_US = 2
/// - NN_QuoteMktType_SH = 3
/// - NN_QuoteMktType_SZ = 4
/// - NN_QuoteMktType_FUT_HK = 5     ← 港期老
/// - NN_QuoteMktType_FUT_HK_NEW = 6 ← 港期新（主要）
/// - NN_QuoteMktType_US_OPTIONS = 7
/// - NN_QuoteMktType_US_FUT = 8     ← 美期
/// - NN_QuoteMktType_HK_OPTIONS = 9
/// - NN_QuoteMktType_SH_KCB = 10
/// - NN_QuoteMktType_Forex = 11
/// - NN_QuoteMktType_SG_FUTURE = 13 ← 新加坡期货（跳 12）
/// - NN_QuoteMktType_JP_FUTURE = 16 ← 日本期货（跳 14-15）
///
/// v1.4.47 P1.2 曾改用 QotMarket 值（HK=1, US=11, ...），以为"QuoteMktType
/// 不等于 QotMarket 就不对"—— **反了方向**。CMD 6822 backend 接受的是
/// NN_QuoteMktType。HK/US/SH/SZ 的 QotMarket 值（1/11/21/22）对 backend 来说
/// 部分 work 是因为：1 ↔ NN_QuoteMktType_HK=1 巧合对齐；其他（US=11 / SH=21
/// / SZ=22）不在 NN_QuoteMktType 枚举范围内 backend 可能 fallback 全市场
/// 返回。但 HKFuture / USFuture / SGFuture / JPFuture 都返 0（因为 v1.4.47
/// 把它们改 reserved[0]=0 导致 backend 不订阅 HK 期货 → eli 报告 #5）。
///
/// 本次修法：**按 C++ SubEventNotice 实装**。期货按 FUT_HK_NEW=6 / US_FUT=8
/// / SG_FUTURE=13 / JP_FUTURE=16 订阅 → backend CMD 6823 响应能返 HK 期货
/// market_id（5-6 / 110-119）→ pick_market_state 能拿到 HK future state。
fn quote_mkt_to_nn_mkt_type(m: QuoteMktType) -> u8 {
    match m {
        QuoteMktType::HK => 1,        // NN_QuoteMktType_HK
        QuoteMktType::US => 2,        // NN_QuoteMktType_US
        QuoteMktType::SH => 3,        // NN_QuoteMktType_SH
        QuoteMktType::SZ => 4,        // NN_QuoteMktType_SZ
        QuoteMktType::HKFuture => 5,  // NN_QuoteMktType_FUT_HK（老港期）
        QuoteMktType::HKFuture2 => 6, // NN_QuoteMktType_FUT_HK_NEW（主要港期）
        QuoteMktType::USOption => 7,  // NN_QuoteMktType_US_OPTIONS
        QuoteMktType::USFuture => 8,  // NN_QuoteMktType_US_FUT
        QuoteMktType::HKOption => 9,  // NN_QuoteMktType_HK_OPTIONS
        QuoteMktType::SHKC => 10,     // NN_QuoteMktType_SH_KCB
        QuoteMktType::Forex => 11,    // NN_QuoteMktType_Forex
        QuoteMktType::SGFuture => 13, // NN_QuoteMktType_SG_FUTURE（C++ 跳 12）
        QuoteMktType::JPFuture => 16, // NN_QuoteMktType_JP_FUTURE（C++ 跳 14-15）
        // v1.4.49 新增 variant 多数不在 NN_QuoteMktType，仅用于 pick_market_state
        // 按 MarketID 过滤。返 0 → backend 忽略（CMD 6822 订阅 reserved[0]=0 可能
        // 表示"通用"，不影响其他订阅的市场）。DigitalCcy 是例外：C++ 10.5.6508
        // 新增 NN_QuoteMktType_CRYPTO=17，需实际注册/拉取 crypto market status。
        QuoteMktType::DigitalCcy => 17, // C++ NN_QuoteMktType_CRYPTO
        QuoteMktType::Bond
        | QuoteMktType::GlobalIndex
        | QuoteMktType::SGSecurity
        | QuoteMktType::StockConnect
        | QuoteMktType::TreasuryYield
        | QuoteMktType::Fund
        | QuoteMktType::Unknown => 0,
    }
}

/// 构造行情命令的 header reserved 字段。
///
/// v1.4.47 P1.2 修：`reserved[0]` 用 Futu QotMarket 值（不是内部 enum 值）。
pub fn make_quote_reserved(mkt: QuoteMktType, ex_type: u8) -> [u8; 10] {
    let mut reserved = [0u8; 10];
    reserved[0] = quote_mkt_to_nn_mkt_type(mkt);
    reserved[1] = ex_type;
    reserved
}

/// 缓存的证券信息 (从 CSStockItem 解析)
#[derive(Debug, Clone)]
pub struct StockInfo {
    pub stock_id: u64,
    pub sequence: u64,
    pub code: String,
    pub name_sc: String,
    pub name_tc: String,
    pub name_en: String,
    pub market_code: u32,
    pub instrument_type: u32,
    pub sub_instrument_type: u32,
    pub lot_size: u32,
    pub currency_code: u32,
    pub listing_date: u32,
    pub delisting: bool,
    pub delete_flag: bool,
    /// 窝轮所属正股 ID (warrnt_stock_owner), 0 表示无
    pub warrnt_stock_owner: u64,
    /// 不可搜索标记 (no_search), true 表示不可搜索
    pub no_search: bool,
    /// v1.4.106 codex F5: 期货主连合约关联 stock_id (proto field 41 origin_id).
    ///
    /// 含义 (对齐 C++ `Ndt_Qot_SecInfo::nFutureOriginID`): 当前 row 是**主连合约**
    /// (e.g. `HSImain`, `NQmain`) 时, `origin_id` 指向真实月份合约的 stock_id;
    /// 普通合约 (`HSI2604` / `NQ2606`) 此字段为 0.
    ///
    /// **F5 用途**: PlaceOrder 在 `IsFuturesTrdMarket && origin_id != 0` 时
    /// 异步发 CMD 6747 拉真实合约 code, 用真实 code 下单 (对齐 C++
    /// `APIServer_Trd_PlaceOrder.cpp:632-650` `ReqMainLinkContract` 流程).
    pub future_origin_id: u64,
    /// v1.4.106 codex F5: 期货主力合约 stock_id (proto field 40 zhuli_id).
    ///
    /// 含义: 主连合约持有此字段, 指向当前**主力合约** stock_id (流动性最大).
    /// CMD 6747 响应解析此字段后用 `id_to_key` 反查 code → 替换 PlaceOrder
    /// `c2s.code` 后下发. 普通合约此字段为 0.
    pub zhuli_id: u64,
    /// Crypto 货币对左侧货币 (C++ `CSStockItem.cc_origin`, proto field 60).
    pub cc_origin: String,
    /// Crypto 货币对右侧货币 (C++ `CSStockItem.cc_destination`, proto field 61).
    pub cc_destination: String,
    /// v1.4.110 final E.5 P2#6: 交易所 (proto field 57, e.g. "SEHK", "NASDAQ").
    ///
    /// 数据驱动 fallback (pitfall #35 C++ 数据驱动 vs Rust 启发式): trade
    /// handler 的 `derive_exchange_str` 应优先用此字段, 缺失时再 fallback 到
    /// pattern match heuristic. backend 不下发此字段时为空串.
    pub exchange: String,
    /// v1.4.110 final E.5 P2#6: 上市交易所 (proto field 74).
    ///
    /// 通常与 `exchange` 相同, dual-listed ADR / 双重主要上市等场景下不同
    /// (e.g. 港股通的 H 股可能 exchange=HKEX, listed_exchange=SEHK).
    pub listed_exchange: String,
}

/// 同步结果
pub struct SyncResult {
    pub total_stocks: usize,
    pub next_interval_secs: u32,
}

/// 同步股票列表 (CMD 6746)
///
/// 从后端增量拉取股票列表。响应经 zlib 压缩，需解压后解析。
/// 返回同步的股票总数和下次同步间隔。
pub async fn sync_stock_list<F>(
    backend: &BackendConn,
    version: &std::sync::atomic::AtomicU64,
    on_stock: &mut F,
) -> Result<SyncResult>
where
    F: FnMut(StockInfo),
{
    use prost::Message;

    let mut total = 0usize;
    let mut next_interval = 150u32;
    const MAX_PAGES: usize = 500; // 防止无限循环

    for _page in 0..MAX_PAGES {
        let cur_version = version.load(std::sync::atomic::Ordering::Relaxed);

        let req = stock_list_sync_svr::StockListReq {
            stock_list_version: cur_version,
            if_req_all: 0, // delta sync
            special_version: Some(1),
        };

        let resp = backend
            .request(CMD_UPDATE_SEC_LIST, req.encode_to_vec())
            .await?;

        // 响应是 zlib (gzip) 压缩的，需要解压
        let decompressed = decompress_gzip(&resp.body)?;

        let parsed: stock_list_sync_svr::StockListRsp = Message::decode(decompressed.as_slice())
            .map_err(|e| FutuError::Codec(format!("CMD6746 decode failed: {e}")))?;

        if parsed.result != 0 {
            return Err(FutuError::Codec(format!(
                "CMD6746 error: result={}",
                parsed.result
            )));
        }

        // 处理每个 CSStockItem
        let batch_count = parsed.arry_items.len();
        for item in &parsed.arry_items {
            let info = parse_stock_item(item);
            if info.delete_flag {
                // 删除的股票也通知上层处理
            }
            on_stock(info);
            total += 1;
        }

        // 更新版本号
        if let Some(max_ver) = parsed.array_max_version {
            version.store(max_ver, std::sync::atomic::Ordering::Relaxed);
        }

        // 更新下次请求间隔
        if let Some(interval) = parsed.next_request_interval {
            next_interval = interval;
        }

        let all_count = parsed.all_count.unwrap_or(0);
        tracing::debug!(
            batch = batch_count,
            total,
            all_count,
            version = version.load(std::sync::atomic::Ordering::Relaxed),
            "stock list sync batch"
        );

        // if_all_rsp != 0 表示拉取完成
        if parsed.if_all_rsp.unwrap_or(1) != 0 {
            // 校验 checksum (debug-log only, 不 enforce mismatch)
            // v1.4.110 final E.5 P3#8: id_check_sum / seq_check_sum 已标 deprecated
            // (新客户端走 id_check_sum_v2 / seq_check_sum_v2, 64+64 bit 拆分避免溢出).
            // server 仍下发老字段一段时间, Rust 保留读取兼容. allow(deprecated) 显式表态.
            #[allow(deprecated)]
            if let (Some(server_id_sum), Some(server_seq_sum)) =
                (parsed.id_check_sum, parsed.seq_check_sum)
                && (server_id_sum > 0 || server_seq_sum > 0)
            {
                tracing::debug!(server_id_sum, server_seq_sum, "server checksums received");
            }
            // v2 校验和 (新 server 下发, debug-log only, 同样不 enforce).
            if let (Some(id_v2), Some(seq_v2)) = (&parsed.id_check_sum_v2, &parsed.seq_check_sum_v2)
            {
                tracing::debug!(
                    id_low = id_v2.low,
                    id_high = id_v2.high,
                    seq_low = seq_v2.low,
                    seq_high = seq_v2.high,
                    "server v2 checksums received"
                );
            }
            break;
        }
    }

    Ok(SyncResult {
        total_stocks: total,
        next_interval_secs: next_interval,
    })
}

/// 注册市场事件推送 (CMD 6822)
///
/// 需要对每个市场单独发送注册请求。
/// header reserved[0] = market_type, reserved[1] = 0 (SECURITY)
pub async fn register_markets(backend: &BackendConn) -> Result<()> {
    // v1.4.57 P2 (外部报告 #4): 加 HKFuture / USFuture / SGFuture / JPFuture
    // 订阅，让 CMD 6823 全市场 snapshot 能返期货市场状态（之前 HK 期货一直 0）。
    // 对齐 C++ `NNBiz_Qot_EventNotice.cpp::SubEventNotice()`：
    // - 港期必须同时订阅 FUT_HK=5 和 FUT_HK_NEW=6。
    // - 10.5.6508 新增 crypto，需订阅 NN_QuoteMktType_CRYPTO=17。
    let markets = [
        (QuoteMktType::HK, "HK"),
        (QuoteMktType::US, "US"),
        (QuoteMktType::SH, "SH"),
        (QuoteMktType::SZ, "SZ"),
        (QuoteMktType::HKFuture, "HKFuture"),
        (QuoteMktType::HKFuture2, "HKFuture2"),
        (QuoteMktType::USFuture, "USFuture"),
        (QuoteMktType::SGFuture, "SGFuture"),
        (QuoteMktType::JPFuture, "JPFuture"),
        (QuoteMktType::DigitalCcy, "DigitalCcy"),
    ];

    for (mkt, name) in &markets {
        let req = ft_cmd6822::RegisterReq { reserved: 0 };
        let reserved = make_quote_reserved(*mkt, 0); // ex_type = SECURITY

        match backend
            .request_with_reserved(
                CMD_EVENT_NOTICE_SUB,
                prost::Message::encode_to_vec(&req),
                reserved,
            )
            .await
        {
            Ok(resp) => {
                let parsed: ft_cmd6822::RegisterRes = prost::Message::decode(resp.body.as_ref())
                    .unwrap_or(ft_cmd6822::RegisterRes { res: -1 });
                if parsed.res != 0 {
                    tracing::warn!(
                        market = name,
                        res = parsed.res,
                        "CMD6822 registration failed"
                    );
                } else {
                    tracing::debug!(market = name, "CMD6822 registered");
                }
            }
            Err(e) => {
                tracing::warn!(market = name, error = %e, "CMD6822 request failed");
            }
        }
    }

    Ok(())
}

/// 拉取市场状态 (CMD 6823)
pub async fn pull_market_status(backend: &BackendConn) -> Result<Vec<MarketStatus>> {
    let markets = [
        (QuoteMktType::HK, "HK"),
        (QuoteMktType::US, "US"),
        (QuoteMktType::SH, "SH"),
    ];

    let mut all_status = Vec::new();

    for (mkt, name) in &markets {
        let req = ft_cmd6823::MarketStatusReq { reserved: 0 };
        let reserved = make_quote_reserved(*mkt, 0);

        match backend
            .request_with_reserved(
                CMD_PULL_EVENT_NOTICE,
                prost::Message::encode_to_vec(&req),
                reserved,
            )
            .await
        {
            Ok(resp) => {
                let parsed = decode_market_status_rsp(resp.body.as_ref())?;
                for s in &parsed.res_status {
                    all_status.push(MarketStatus {
                        market_id: s.id,
                        status: s.status.unwrap_or(0),
                        status_text: s.status_text_sc.clone().unwrap_or_default(),
                    });
                }
                tracing::debug!(
                    market = name,
                    count = parsed.res_status.len(),
                    "CMD6823 status"
                );
            }
            Err(e) => {
                tracing::warn!(market = name, error = %e, "CMD6823 request failed");
            }
        }
    }

    Ok(all_status)
}

fn decode_market_status_rsp(body: &[u8]) -> Result<ft_cmd6823::MarketStatusRsp> {
    prost::Message::decode(body).map_err(FutuError::Proto)
}

/// 市场状态
#[derive(Debug, Clone)]
pub struct MarketStatus {
    pub market_id: u32,
    pub status: u32,
    pub status_text: String,
}

/// v1.4.48 修：CMD 6823 返回**全市场**子交易所列表（~100+ 条），一次查询即可拿所有市场
/// 状态。旧版 (v1.4.47) 8 次查询 + 盲取 `statuses[0]` 导致误读市场状态。
///
/// 参考 C++ `market_tradingDay.proto::MarketID` enum:
/// - 1-4: HK 股票 (主板/创业板/纳斯达克/扩展板)
/// - 5-6: HK Future (old / new)
/// - 7-8: HK Option
/// - 10-29: US 股票 (NYSE, NASDAQ, AMEX, ...)
/// - 30-40: CN A 股 (SH / SZ)
/// - 41-45: US Option
/// - 60-109: US Future (NYMEX=60, COMEX=70, CBOT 80-84, CME 90-99, CBOE 100-109)
/// - 110-119: HK Future 扩展
/// - 120-123: Forex
/// - 130-159: Bonds
/// - 50-51: Stock Connect (港股通 / A股通) — v1.4.49 加
/// - 60-109: US Future (NYMEX, COMEX, CBOT, CME, CBOE)
/// - 110-119: HK Future 扩展
/// - 120-123: Forex
/// - 130-159: Bonds — v1.4.49 加
/// - 160-179: SGX Future
/// - 180-184: SGX Market (新加坡股票) — v1.4.49 加
/// - 185-194: JPX Future
/// - 260-359: Global Index — v1.4.49 加
/// - 360-459: Digital Currency — v1.4.49 加
/// - 460-559: Treasury Yield — v1.4.49 加
/// - 560-569: Fund — v1.4.50 加（`NN_QuoteMktID_FUND_*`）
/// - 570-579: HK Index Option 扩展 — v1.4.50 加入 HKOption
/// - 1000-1049: HK HSI Index — v1.4.50 加入 HK（C++ 源码确认归 HK 市场）
/// - 1200-1249: US New VIX — v1.4.50 加入 US（C++ 源码确认归 US 市场）
pub fn market_id_matches(mkt: QuoteMktType, id: u32) -> bool {
    match mkt {
        // v1.4.50: HK 加 1000-1049（HSI Index 扩展，C++ 映射归 HK 市场）
        QuoteMktType::HK => (1..=4).contains(&id) || (1000..=1049).contains(&id),
        QuoteMktType::HKFuture | QuoteMktType::HKFuture2 => {
            (5..=6).contains(&id) || (110..=119).contains(&id)
        }
        // v1.4.50: HKOption 加 570-579（HK Index Option 扩展）
        QuoteMktType::HKOption => (7..=8).contains(&id) || (570..=579).contains(&id),
        // v1.4.50: US 加 1200-1249（US New VIX，C++ 映射归 US 市场）
        QuoteMktType::US => (10..=29).contains(&id) || (1200..=1249).contains(&id),
        QuoteMktType::SH | QuoteMktType::SZ | QuoteMktType::SHKC => (30..=40).contains(&id),
        QuoteMktType::USOption => (41..=45).contains(&id),
        QuoteMktType::USFuture => (60..=109).contains(&id),
        QuoteMktType::SGFuture => (160..=179).contains(&id),
        QuoteMktType::JPFuture => (185..=194).contains(&id),
        QuoteMktType::Forex => (120..=123).contains(&id),
        // v1.4.49 新增 6 个 variant（对齐 C++ market_tradingDay.proto MarketID）
        QuoteMktType::StockConnect => (50..=51).contains(&id),
        QuoteMktType::Bond => (130..=159).contains(&id),
        QuoteMktType::SGSecurity => (180..=184).contains(&id),
        QuoteMktType::GlobalIndex => (260..=359).contains(&id),
        QuoteMktType::DigitalCcy => (360..=459).contains(&id),
        QuoteMktType::TreasuryYield => (460..=559).contains(&id),
        // v1.4.50 新增
        QuoteMktType::Fund => (560..=569).contains(&id),
        QuoteMktType::Unknown => false,
    }
}

/// v1.4.48 新：一次 CMD 6823 query 拿全市场状态 snapshot，避免重复 8 次查询。
///
/// **v1.4.55 修正**（同事反馈 `market_hkfuture: NONE` 即使夜盘交易中）：
/// backend 对 CMD 6823 在 reserved=HK 时返的 snapshot **不含期货市场**
/// （HK 主板 / 港股通 / US / CN / Bond 等都在，但 HK/US/SG/JP 期货 market_id 缺席）。
/// 真机实测 v1.4.48 一次 snapshot 里 market_hk/us/sh/sz 都能填，但
/// market_hk_future / market_us_future / market_sg_future / market_jp_future 全是
/// `NONE`。
///
/// **修法**：并发发 5 个 CMD 6823（HK / HKFuture / USFuture / SGFuture /
/// JPFuture），合并结果按 `market_id` 去重。backend 对 `reserved=HKFuture` 等
/// 期货 market type 会下发对应 market_id ∈ {5, 6, 110-119} (HK) / 60-109 (US) /
/// 160-179 (SG) 的状态条目，合并后 `pick_market_state(HKFuture)` 就能命中。
///
/// 代价：5 个并发请求而非 1 个（~5x backend load），但 CMD 6823 是轻量 snapshot，
/// 实测每次 ~10-20ms，合计 <100ms 仍在可接受范围（global_state 不是高频 API）。
pub async fn pull_all_market_status(backend: &BackendConn) -> Result<Vec<MarketStatus>> {
    use futures::future::join_all;

    let req = ft_cmd6823::MarketStatusReq { reserved: 0 };
    let req_bytes = prost::Message::encode_to_vec(&req);

    // 按 C++ `PullEventNotice` 的 market type 维度主动拉取状态。Crypto 在
    // C++ 10.5.6508 中走 NN_QuoteMktType_CRYPTO=17。
    let market_types = [
        QuoteMktType::HK,        // 非期货市场全量（HK 主板 / 港股通 / US / CN / Bond / etc）
        QuoteMktType::HKFuture,  // 老港期（NN_QuoteMktType_FUT_HK=5，MktID 5 / 110-119）
        QuoteMktType::HKFuture2, // 主要港期（NN_QuoteMktType_FUT_HK_NEW=6，MktID 6 / 110-119）
        QuoteMktType::USFuture,  // US 期货（NN_QuoteMktType_US_FUT=8，MktID 60-109）
        QuoteMktType::SGFuture,  // SG 期货（NN_QuoteMktType_SG_FUTURE=13，MktID 160-179）
        QuoteMktType::JPFuture,  // JP 期货（NN_QuoteMktType_JP_FUTURE=16，MktID 185-194）
        QuoteMktType::DigitalCcy, // 数字货币（NN_QuoteMktType_CRYPTO=17，MktID 360-459）
    ];

    let pulls = market_types.iter().map(|mkt| {
        let reserved = make_quote_reserved(*mkt, 0);
        let body = req_bytes.clone();
        async move {
            backend
                .request_with_reserved(CMD_PULL_EVENT_NOTICE, body, reserved)
                .await
        }
    });
    let results = join_all(pulls).await;

    let mut seen_ids = std::collections::HashSet::new();
    let mut statuses: Vec<MarketStatus> = Vec::new();
    for (mkt, resp_result) in market_types.iter().zip(results) {
        match resp_result {
            Ok(resp) => {
                let parsed = decode_market_status_rsp(resp.body.as_ref())?;
                for s in &parsed.res_status {
                    if seen_ids.insert(s.id) {
                        statuses.push(MarketStatus {
                            market_id: s.id,
                            status: s.status.unwrap_or(0),
                            status_text: s.status_text_sc.clone().unwrap_or_default(),
                        });
                    }
                }
            }
            Err(e) => {
                // 单个 market 拉失败不 block 整体，warn 继续
                tracing::warn!(
                    market_type = ?mkt,
                    error = %e,
                    "v1.4.55 CMD6823 one market pull failed, continuing with others"
                );
            }
        }
    }

    tracing::debug!(
        total_entries = statuses.len(),
        market_types_pulled = market_types.len(),
        "v1.4.55 CMD6823 multi-market snapshot fetched"
    );
    for s in &statuses {
        tracing::trace!(
            market_id = s.market_id,
            status = s.status,
            status_text = %s.status_text,
            "CMD6823 entry"
        );
    }

    // v1.4.57 P2 (外部报告 #4): 额外打 DEBUG 汇总所有 market_id 值（逗号分隔），
    // 方便在字段级别 diagnostic "HK 期货 market_id 在哪个范围 backend 返" 这类问题。
    // 发版日志开 RUST_LOG=debug 时可看见，正常级别不出。
    if !statuses.is_empty() && tracing::enabled!(tracing::Level::DEBUG) {
        let ids: Vec<String> = statuses.iter().map(|s| s.market_id.to_string()).collect();
        tracing::debug!(
            count = statuses.len(),
            market_ids = %ids.join(","),
            "v1.4.57 CMD6823 all received market_ids (for HK futures / etc. diagnostic)"
        );
    }

    Ok(statuses)
}

/// v1.4.48 helper: 从全市场 snapshot 里按 `QuoteMktType` 过滤 + 取状态。
///
/// **v1.4.71 D5 fix**（eli v1.4.69 `market_hk_future=0` 报告，代码级定位到本函数）：
/// 之前 `.find` 取第一个匹配 → 对 `HKFuture` 同时匹配 `FUT_HK=5`（老港期，已
/// deprecated 但 backend 仍下发，status 常为 0=NOT_TRADING）和 `FUT_HK_NEW=6`
/// （主要港期，open 时 status=15=FUTURE_DAY_OPEN），如果 id=5 在 list 里排前面，
/// 结果会返 0 遮蔽主要市场真实状态。修法：**优先返 non-zero status 的匹配**，
/// 全 zero 才 fallback 到第一个。
///
/// **v1.4.73 B1 D5 升级**（eli v1.4.71 AI tester 报告 "Rust 对 HK/JP/SG 期货全
/// 返 15，C++ SG 返 18=FUTURE_DAY_WAIT_OPEN"）：同一个 `QuoteMktType` 范围
/// 内 backend 可能下发多条 non-zero status（如 SGFuture 多个子交易所），当
/// 同时有"开盘"类（15 / 23 / 3 / 5 / 13）和"等待开盘 / 休市"类（2 / 4 / 6 /
/// 11 / 14 / 16 / 17 / 18 / 9 / 1）时，**优先返后者**（更精确描述市场实际情况：
/// 不能交易的状态永远比"能交易"更安全，防止客户端误判"等待开盘"为"已开盘"下
/// 单被拒）。
///
/// 对齐 C++ `APIServer_GlobalState.cpp:87-94` 的语义 —— C++ 仅取
/// `pMktStateInfo[0]`，但是 backend 层 `INNData_Qot_EventNotice::GetMarketStateInfo`
/// 按 enum 精确 dispatch，不会混多个 market_id。Rust 的 `market_id_matches`
/// 按 range 匹配，会得到多条，所以要在 selection 上做 "prefer restrictive"
/// 来对齐 C++ 实际观测行为。
///
/// 无匹配 → None。
pub fn pick_market_state(all: &[MarketStatus], mkt: QuoteMktType) -> Option<u32> {
    let mut best: Option<u32> = None;
    let mut best_priority: u8 = 0;

    for s in all.iter().filter(|s| market_id_matches(mkt, s.market_id)) {
        let pri = market_state_priority(s.status);
        if pri > best_priority {
            best = Some(s.status);
            best_priority = pri;
        } else if best.is_none() {
            best = Some(s.status);
        }
    }
    best
}

/// v1.4.73 B1 D5 升级：按"描述市场实际情况"优先级对 `QotMarketState` 打分。
///
/// | Priority | Meaning | Values |
/// |---|---|---|
/// | 0 | None / zero | 0 |
/// | 1 | Open / 可交易 | 3 (Morning), 5 (Afternoon), 13 (NightOpen), 15 (FutureDayOpen), 23 (FutureOpen) |
/// | 2 | Restrictive / 不可交易 或 精确状态 | 1 (Auction), 2 (WaitingOpen), 4 (Rest), 6 (Closed), 8 (PreMarketBegin), 9 (PreMarketEnd), 10 (AfterHoursBegin), 11 (AfterHoursEnd), 14 (NightEnd), 16 (FutureDayBreak), 17 (FutureDayClose), 18 (FutureDayWaitForOpen), 19 (HkCas) |
///
/// 同一 market 多个 market_id 返 non-zero 时，按 priority 选最高。priority
/// 相同时选第一个（保持 v1.4.71 first-non-zero 行为）。
///
/// 对齐 proto `Qot_Common.QotMarketState` 值（0-19 全覆盖；未来新增 variant
/// 默认归到 priority 1，保守 fallback）。
fn market_state_priority(status: u32) -> u8 {
    match status {
        0 => 0,
        // 可交易 / 开盘状态
        3 | 5 | 13 | 15 | 23 => 1,
        // 不可交易 / 等待 / 休市 / 精确 pre/after-market 状态
        1 | 2 | 4 | 6 | 8..=11 | 14 | 16..=19 | 12 => 2,
        // 未知新增 variant → 保守 fallback
        _ => 1,
    }
}

/// 拉取单个市场的状态 (CMD 6823) — v1.4.48 legacy API，保持兼容
///
/// 建议用 `pull_all_market_status` + `pick_market_state` 替代（一次查询拿所有市场）。
pub async fn pull_single_market_status(
    backend: &BackendConn,
    mkt: QuoteMktType,
) -> Result<Vec<MarketStatus>> {
    let all = pull_all_market_status(backend).await?;
    Ok(all
        .into_iter()
        .filter(|s| market_id_matches(mkt, s.market_id))
        .collect())
}

/// FTAPI QotMarket → 后端 QuoteMktType
pub fn qot_market_to_backend(qot_market: i32) -> Option<QuoteMktType> {
    match qot_market {
        1 => Some(QuoteMktType::HK),
        2 => Some(QuoteMktType::HKFuture),
        11 => Some(QuoteMktType::US),
        21 => Some(QuoteMktType::SH),
        22 => Some(QuoteMktType::SZ),
        91 => Some(QuoteMktType::DigitalCcy),
        _ => None,
    }
}

/// v1.4.47 P1.2 修（eli 验收报告 §3 P2 / §14.3 根因）：
/// FTAPI **TrdMarket** → 后端 `QuoteMktType`。
///
/// 注意：TrdMarket 和 QotMarket **是两个不同的 enum**，数值不相同：
/// - TrdMarket: HK=1, US=2, CN=3, HKCC=4, Futures=5, SG=6, AU=8, JP=15, MY=111, CA=112
/// - QotMarket: HK_Security=1, HK_Future=2, US_Security=11, CNSH=21, CNSZ=22, SG=31, JP=41, AU=51, MY=61, CA=71, FX=81
///
/// v1.4.93 BUG-001 fix (S level ship-blocker): 之前注释里 TrdMarket JP=7 / AU=8 /
/// CA=9 是错的 (那是 SecurityFirm 编号). 真实 `Trd_Common.proto::TrdMarket` 是
/// JP=15 / AU=8 / CA=112 / MY=111. 注释纠正以防日后 reader 又踩坑.
///
/// 旧 bug：`maybe_annotate_market_closed` 把 TrdMarket=2（US）直接传给
/// `qot_market_to_backend`（期望 QotMarket），被识别为 QotMarket=2（HK_Future）
/// → backend 返 HK_Future 状态而不是 US 状态 → hint 永远说"US 非交易时段"
/// （因为 HK_Future 在 HKT 23:00 确实 Closed）。修：独立 TrdMarket 映射函数。
///
/// 对齐 CLAUDE.md 核心原则"与 C++ OpenD 零差异"：C++ `Trd_Common.TrdMarket` 和
/// `Qot_Common.QotMarket` 一直是独立 enum，我们之前混用是 bug。
pub fn trd_market_to_backend(trd_market: i32) -> Option<QuoteMktType> {
    match trd_market {
        1 | 4 => Some(QuoteMktType::HK), // HK / HKCC → HK_Security
        2 => Some(QuoteMktType::US),     // US stock
        3 => Some(QuoteMktType::SH),     // CN A 股（默认 SH；SZ 由 code 前缀区分，
        // 但 market-state 查询粒度到不了 symbol 层，先用 SH）
        5 => Some(QuoteMktType::HKFuture), // Futures
        7 => Some(QuoteMktType::DigitalCcy),
        // v1.4.93 BUG-001 fix: SG=6 / AU=8 / JP=15 / MY=111 / CA=112 - QuoteMktType enum
        // 未收录，backend market-state CMD 不支持这些市场子类型的 state 查询
        // （只支持 HK/US/CN/HKFuture）。返 None 让 hint 跳过 market-state 注解.
        _ => None,
    }
}

// ===== 内部函数 =====

/// 解压 gzip/zlib 压缩数据
fn decompress_gzip(data: &[u8]) -> Result<Vec<u8>> {
    if data.is_empty() {
        return Ok(vec![]);
    }

    let mut decoder = GzDecoder::new(data);
    let mut decompressed = Vec::new();
    match decoder.read_to_end(&mut decompressed) {
        Ok(_) => Ok(decompressed),
        Err(_) => {
            // 可能不是 gzip 压缩，尝试 zlib
            let mut decoder = flate2::read::ZlibDecoder::new(data);
            let mut decompressed = Vec::new();
            match decoder.read_to_end(&mut decompressed) {
                Ok(_) => Ok(decompressed),
                Err(_) => {
                    // 可能本身就没压缩，直接返回原始数据
                    tracing::debug!(len = data.len(), "data not compressed, using raw");
                    Ok(data.to_vec())
                }
            }
        }
    }
}

/// 后端 InstrumentTypeV2 → FTAPI NN_QuoteSecurityType (V1) 映射
/// 对齐 C++ QuoteSecurityTypeV2ToV1()
fn instrument_type_v2_to_v1(type_v2: u32) -> u32 {
    match type_v2 {
        1 | 13 => 1,          // BOND, OTC_BOND → Bond
        3 => 3,               // EQUITY → Eqty
        2 | 4 | 12 | 19 => 4, // WEALTH_MANAGE, FUND, TRUST, OLD_OTC_STRUCT_NOTES → Trust
        5 => 5,               // WARRANT → Warrant
        6 => 6,               // INDEX → Index
        7 => 7,               // PLATE → Plate
        8 => 8,               // OPTION → Drvt
        15 => 9,              // PLATE_SET → PlateSet
        9 => 10,              // FUTURE → Future
        10 => 11,             // FOREX → Forex
        _ => 0,               // Unknown
    }
}

/// 从 CSStockItem 解析 StockInfo
fn parse_stock_item(item: &stock_list_sync_svr::CsStockItem) -> StockInfo {
    // C++ 只使用 instrument_type_v2 并通过 QuoteSecurityTypeV2ToV1 转换
    // V1 instrument_Type 字段完全不使用（对齐 C++ SecListDBUpdater）
    let instrument_type = if let Some(v2) = item.instrument_type_v2 {
        instrument_type_v2_to_v1(v2)
    } else {
        0 // 无 V2 时默认 Unknown，与 C++ 保持一致
    };

    StockInfo {
        stock_id: item.stock_id,
        sequence: item.sequence,
        code: item.code.clone(),
        name_sc: item.sc_name.clone().unwrap_or_default(),
        name_tc: item.tc_name.clone().unwrap_or_default(),
        name_en: item.eng_name.clone().unwrap_or_default(),
        market_code: item.market_code.unwrap_or(0),
        instrument_type,
        sub_instrument_type: item.sub_instrument_type.unwrap_or(0),
        lot_size: item.lot_size.unwrap_or(0),
        currency_code: item.currency_code.unwrap_or(0),
        listing_date: item.listing_date.unwrap_or(0),
        delisting: item.delisting_flag.unwrap_or(0) != 0,
        delete_flag: item.delete_flag.unwrap_or(0) != 0,
        warrnt_stock_owner: item.warrnt_stock_owner.unwrap_or(0),
        no_search: item.no_search.unwrap_or(0) != 0,
        // v1.4.106 codex F5: 期货主连合约字段 (proto field 40/41)
        future_origin_id: item.origin_id.unwrap_or(0),
        zhuli_id: item.zhuli_id.unwrap_or(0),
        cc_origin: item.cc_origin.clone().unwrap_or_default(),
        cc_destination: item.cc_destination.clone().unwrap_or_default(),
        // v1.4.110 final E.5 P2#6: 补 exchange + listed_exchange (proto field 57/74)
        // C++ Quote/stock_list_sync.proto:215,221. 数据驱动来源, 优先于 pattern fallback.
        exchange: item.exchange.clone().unwrap_or_default(),
        listed_exchange: item.listed_exchange.clone().unwrap_or_default(),
    }
}

#[cfg(test)]
mod tests;