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};

mod market;
mod parse;

use market::market_state_priority;
#[cfg(test)]
use market::quote_mkt_to_nn_mkt_type;
pub use market::{
    QuoteMktType, make_quote_reserved, market_id_matches, qot_market_to_backend,
    trd_market_to_backend,
};
use parse::parse_stock_item;

/// 股票列表同步命令 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;

/// 缓存的证券信息 (从 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,
    /// C++ `Ndt_Qot_SecInfo::szNameJp`, from stock_list_sync `CSStockItem.ja_name` field 65.
    pub name_jp: String,
    pub market_code: u32,
    pub instrument_type: u32,
    /// C++ `Ndt_Qot_SecInfo::nSpreadCode` data source.
    ///
    /// Source: stock_list_sync `CSStockItem.spread_table_code` field 13.
    pub spread_table_code: u32,
    pub sub_instrument_type: u32,
    /// C++ `Ndt_Qot_SecInfo::enSubTypeV2` data source.
    ///
    /// Source: stock_list_sync `CSStockItem.sub_instrument_type_v2` field 69.
    /// v10.6 `GetCompanyProfile` uses this to split Trust/ETF routing exactly like
    /// C++ `APIServer_Qot_CompanyProfile.cpp:55-63`.
    pub sub_instrument_type_v2: 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,
    /// C++ internal `NN_QotWarrantType` from stock-list `warrnt_type`.
    ///
    /// Values 1-5 match public `Qot_Common.WarrantType`; values 6/7 are C++
    /// internal DLC Long/Short and are filtered out by `GetReference(WARRANT)`.
    pub warrant_type: u32,
    /// 不可搜索标记 (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,
    pub server_checksum: Option<StockListServerChecksum>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ChecksumV2 {
    pub low: i64,
    pub high: i64,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StockListServerChecksum {
    pub stock_count: Option<i32>,
    pub id_v2: Option<ChecksumV2>,
    pub seq_v2: Option<ChecksumV2>,
}

fn checksum_v2_from_proto(value: &crate::proto_internal::ftcmd6741::CheckSum) -> ChecksumV2 {
    ChecksumV2 {
        low: value.low.unwrap_or(0),
        high: value.high.unwrap_or(0),
    }
}

/// 同步股票列表 (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;
    let mut server_checksum = None;
    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 {
            server_checksum = Some(StockListServerChecksum {
                stock_count: parsed.stock_count,
                id_v2: parsed.id_check_sum_v2.as_ref().map(checksum_v2_from_proto),
                seq_v2: parsed.seq_check_sum_v2.as_ref().map(checksum_v2_from_proto),
            });
            // 校验 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) 显式表态.
            // Removal trigger: 真机/线上日志连续一个 minor release 只出现 v2 checksum
            // 且旧字段始终为 None/0 后，删除本兼容读取与 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,
        server_checksum,
    })
}

/// 注册市场事件推送 (CMD 6822)
///
/// 需要对每个市场单独发送注册请求。
/// header reserved[0] = market_type, reserved[1] = 0 (SECURITY)
pub async fn register_markets(backend: &BackendConn) -> Result<()> {
    // v1.4.57 P2: 加 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。
    // - 10.6 GetGlobalState 新增 SG/MY/JP 股票市场状态，需订阅对应
    //   NN_QuoteMktType_SG_SECURITY/JP_SECURITY/MY_SECURITY。
    let markets = [
        (QuoteMktType::HK, "HK"),
        (QuoteMktType::HKFuture, "HKFuture"),
        (QuoteMktType::HKFuture2, "HKFuture2"),
        (QuoteMktType::HKOption, "HKOption"),
        (QuoteMktType::US, "US"),
        (QuoteMktType::USOption, "USOption"),
        (QuoteMktType::SH, "SH"),
        (QuoteMktType::SHKC, "SHKC"),
        (QuoteMktType::SZ, "SZ"),
        (QuoteMktType::USFuture, "USFuture"),
        (QuoteMktType::SGFuture, "SGFuture"),
        (QuoteMktType::JPFuture, "JPFuture"),
        (QuoteMktType::JPSecurity, "JPSecurity"),
        (QuoteMktType::SGSecurity, "SGSecurity"),
        (QuoteMktType::MYSecurity, "MYSecurity"),
        // Existing Rust extension: crypto status is pulled by C++ PullEventNotice
        // and v1.4.68 wired CMD6822 too; keep it to avoid regressing crypto state.
        (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
/// - 830-849: JP TSE 股票 — v1.4.111 加（C++ `NN_QuoteMktID_JP_TSE_*`）
/// - 1000-1049: HK HSI Index — v1.4.50 加入 HK（C++ 源码确认归 HK 市场）
/// - 1200-1249: US New VIX — v1.4.50 加入 US（C++ 源码确认归 US 市场）
/// - 1350-1399: MY 股票 — v1.4.111 加（C++ `NN_QuoteMktID_MY_Security_*`）
///
/// 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）
        QuoteMktType::HKFuture2, // 主要港期（NN_QuoteMktType_FUT_HK_NEW=6，MktID 6 / 110-119）
        QuoteMktType::HKOption,  // HK 期权（NN_QuoteMktType_HK_OPTIONS=9）
        QuoteMktType::US,        // US 股票（NN_QuoteMktType_US=2）
        QuoteMktType::USOption,  // US 期权（NN_QuoteMktType_US_OPTIONS=7）
        QuoteMktType::SH,        // SH A 股（NN_QuoteMktType_SH=3）
        QuoteMktType::SHKC,      // 科创板（NN_QuoteMktType_SH_KCB=10）
        QuoteMktType::SZ,        // SZ A 股（NN_QuoteMktType_SZ=4）
        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::JPSecurity, // JP 股票（NN_QuoteMktType_JP_SECURITY=25，MktID 830-849）
        QuoteMktType::DigitalCcy, // 数字货币（NN_QuoteMktType_CRYPTO=17，MktID 360-459）
        QuoteMktType::SGSecurity, // SG 股票（NN_QuoteMktType_SG_SECURITY=15，MktID 180-184）
        QuoteMktType::MYSecurity, // MY 股票（NN_QuoteMktType_MY_SECURITY=27，MktID 1350-1399）
    ];

    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**（external reviewer v1.4.69 `market_hk_future=0` 报告，代码级定位到本函数）：
/// 早期 `.find` 取第一个匹配时，公共 HK futures 查询容易先碰到 `FUT_HK=5`
/// （老港期，已 deprecated 但 backend 仍下发，status 常为 0=NOT_TRADING），
/// 从而遮蔽 `FUT_HK_NEW=6`（主要港期，open 时 status=15=FUTURE_DAY_OPEN）。
/// 现在 `HKFuture` / `HKFuture2` 的 market_id 归属已经按 C++
/// `NN_QuoteMktType_From_NN_QuoteMktID` 拆开，主港期全局状态取 `HKFuture2`。
///
/// **v1.4.73 B1 D5 升级**（external reviewer 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）。
/// 拉取单个市场的状态 (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 -> backend QuoteMktType mapping lives in stock_list/market.rs.
// ===== 内部函数 =====

/// 解压 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())
                }
            }
        }
    }
}

#[cfg(test)]
mod tests;