futucli/cmd/

sys.rs

//! v1.4.30：系统元数据查询（global-state / user-info / delay-statistics）
//!
//! - `global-state` → `GetGlobalState` (CMD 1002)
//! - `user-info` → `GetUserInfo` (CMD 1005)
//! - `delay-statistics` → `GetDelayStatistics` (CMD 1007)
//!
//! 这三个 proto 是"网关自身元数据"，对齐 py-futu-api 的 `OpenContext.get_*`。
//! 不走 futu-qot helper，直接 prost 往 futu-net 发。

use anyhow::{Result, anyhow, bail};
use prost::Message;
use serde::Serialize;
use tabled::Tabled;

use crate::common::connect_gateway;
use crate::output::OutputFormat;

mod quote_rights;
mod subscription;
#[cfg(test)]
mod tests;
mod user_info;

pub use quote_rights::run_quote_rights;
#[cfg(test)]
use quote_rights::{quote_right_quota_rows, quote_right_rows, quote_right_user_rows};
pub use subscription::{run_query_subscription, run_unsubscribe, run_used_quota};
pub use user_info::run_user_info;
#[cfg(test)]
use user_info::user_attribution_region_label;

// ============================================================
// global-state
// ============================================================

#[derive(Tabled)]
struct GlobalStateRow {
    #[tabled(rename = "Field")]
    field: String,
    #[tabled(rename = "Value")]
    value: String,
}

#[derive(Serialize)]
struct GlobalStateJson {
    market_hk: i32,
    market_us: i32,
    market_sh: i32,
    market_sz: i32,
    market_hk_future: i32,
    market_us_future: Option<i32>,
    market_sg_future: Option<i32>,
    market_jp_future: Option<i32>,
    market_sg: Option<i32>,
    market_my: Option<i32>,
    market_jp: Option<i32>,
    qot_logined: bool,
    trd_logined: bool,
    server_ver: i32,
    server_build_no: i32,
    server_time: i64,
    conn_id: Option<u64>,
}

// v1.4.31: market_state_label 抽到 futu_qot::types::market_state_label
// （历史 2 份拷贝合并到 leaf crate 统一维护，避免漂移）
use futu_qot::types::market_state_label;
use futu_surface_spec::endpoints::get_delay_statistics::{
    DEFAULT_QOT_PUSH_STAGE, default_segment_list_vec, default_type_list_vec,
};

pub async fn run_global_state(gateway: &str, format: OutputFormat) -> Result<()> {
    let (client, _rx) = connect_gateway(gateway, "futucli-global-state").await?;
    let req = futu_proto::get_global_state::Request {
        c2s: futu_proto::get_global_state::C2s { user_id: 0 },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::GET_GLOBAL_STATE, body)
        .await?;
    let resp = futu_proto::get_global_state::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode global_state: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "global_state ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let rows = vec![
        GlobalStateRow {
            field: "market_hk".into(),
            value: format!("{} ({})", market_state_label(s.market_hk), s.market_hk),
        },
        GlobalStateRow {
            field: "market_us".into(),
            value: format!("{} ({})", market_state_label(s.market_us), s.market_us),
        },
        GlobalStateRow {
            field: "market_sh".into(),
            value: format!("{} ({})", market_state_label(s.market_sh), s.market_sh),
        },
        GlobalStateRow {
            field: "market_sz".into(),
            value: format!("{} ({})", market_state_label(s.market_sz), s.market_sz),
        },
        GlobalStateRow {
            field: "market_hk_future".into(),
            value: format!(
                "{} ({})",
                market_state_label(s.market_hk_future),
                s.market_hk_future
            ),
        },
        GlobalStateRow {
            field: "market_sg".into(),
            value: s
                .market_sg
                .map(|v| format!("{} ({})", market_state_label(v), v))
                .unwrap_or_else(|| "-".into()),
        },
        GlobalStateRow {
            field: "market_my".into(),
            value: s
                .market_my
                .map(|v| format!("{} ({})", market_state_label(v), v))
                .unwrap_or_else(|| "-".into()),
        },
        GlobalStateRow {
            field: "market_jp".into(),
            value: s
                .market_jp
                .map(|v| format!("{} ({})", market_state_label(v), v))
                .unwrap_or_else(|| "-".into()),
        },
        GlobalStateRow {
            field: "qot_logined".into(),
            value: s.qot_logined.to_string(),
        },
        GlobalStateRow {
            field: "trd_logined".into(),
            value: s.trd_logined.to_string(),
        },
        GlobalStateRow {
            field: "server_ver".into(),
            value: s.server_ver.to_string(),
        },
        GlobalStateRow {
            field: "server_build_no".into(),
            value: s.server_build_no.to_string(),
        },
        GlobalStateRow {
            field: "server_time".into(),
            value: s.time.to_string(),
        },
        GlobalStateRow {
            field: "conn_id".into(),
            value: s
                .conn_id
                .map(|c| c.to_string())
                .unwrap_or_else(|| "-".into()),
        },
    ];
    let json = GlobalStateJson {
        market_hk: s.market_hk,
        market_us: s.market_us,
        market_sh: s.market_sh,
        market_sz: s.market_sz,
        market_hk_future: s.market_hk_future,
        market_us_future: s.market_us_future,
        market_sg_future: s.market_sg_future,
        market_jp_future: s.market_jp_future,
        market_sg: s.market_sg,
        market_my: s.market_my,
        market_jp: s.market_jp,
        qot_logined: s.qot_logined,
        trd_logined: s.trd_logined,
        server_ver: s.server_ver,
        server_build_no: s.server_build_no,
        server_time: s.time,
        conn_id: s.conn_id,
    };
    format.print_rows(&rows, &[json])?;
    Ok(())
}

// ============================================================
// delay-statistics
// ============================================================

#[derive(Tabled)]
struct DelayStatRow {
    #[tabled(rename = "Category")]
    category: String,
    #[tabled(rename = "Samples")]
    samples: usize,
}

#[derive(Serialize)]
struct DelayStatJson {
    qot_push_categories: usize,
    req_reply_samples: usize,
    place_order_samples: usize,
}

pub async fn run_delay_statistics(gateway: &str, format: OutputFormat) -> Result<()> {
    let (client, _rx) = connect_gateway(gateway, "futucli-delay-statistics").await?;
    let req = futu_proto::get_delay_statistics::Request {
        c2s: futu_proto::get_delay_statistics::C2s {
            type_list: default_type_list_vec(),
            qot_push_stage: Some(DEFAULT_QOT_PUSH_STAGE),
            segment_list: default_segment_list_vec(),
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::GET_DELAY_STATISTICS, body)
        .await?;
    let resp = futu_proto::get_delay_statistics::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode delay_statistics: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "delay_statistics ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let rows = vec![
        DelayStatRow {
            category: "qot_push".into(),
            samples: s.qot_push_statistics_list.len(),
        },
        DelayStatRow {
            category: "req_reply".into(),
            samples: s.req_reply_statistics_list.len(),
        },
        DelayStatRow {
            category: "place_order".into(),
            samples: s.place_order_statistics_list.len(),
        },
    ];
    let json = DelayStatJson {
        qot_push_categories: s.qot_push_statistics_list.len(),
        req_reply_samples: s.req_reply_statistics_list.len(),
        place_order_samples: s.place_order_statistics_list.len(),
    };
    format.print_rows(&rows, &[json])?;
    Ok(())
}

// ===================================================================
// v1.4.98 T2-8 (mobile-source-audit Phase 2): NN+MM token state query
// CMD 1326 CS_CMDID_NewToken_GetStateInfo
// ===================================================================

#[derive(serde::Serialize, tabled::Tabled)]
struct TokenStateRow {
    /// Token app brand
    brand: String,
    /// 1=已绑定 / 0=未绑定
    bind: u32,
    /// 1=已启用 / 0=未启用
    enable: u32,
}

#[derive(serde::Serialize)]
struct TokenStateJson {
    nn_token_enable: u32,
    nn_token_bind: u32,
    mm_token_enable: u32,
    mm_token_bind: u32,
}

pub async fn run_token_state(gateway: &str, format: OutputFormat) -> Result<()> {
    use futu_backend::proto_internal::futu_token_state;

    let (client, _rx) = connect_gateway(gateway, "futucli-token-state").await?;
    let req = futu_token_state::DaemonGetTokenStateReq {
        c2s: futu_token_state::daemon_get_token_state_req::C2s { app_id: None },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::GET_TOKEN_STATE, body)
        .await?;
    let resp = futu_token_state::DaemonGetTokenStateRsp::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode token_state: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "token_state ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let rows = vec![
        TokenStateRow {
            brand: "NN (Futu Token)".into(),
            bind: s.nn_token_bind.unwrap_or(0),
            enable: s.nn_token_enable.unwrap_or(0),
        },
        TokenStateRow {
            brand: "MM (moomoo Token)".into(),
            bind: s.mm_token_bind.unwrap_or(0),
            enable: s.mm_token_enable.unwrap_or(0),
        },
    ];
    let json = TokenStateJson {
        nn_token_enable: s.nn_token_enable.unwrap_or(0),
        nn_token_bind: s.nn_token_bind.unwrap_or(0),
        mm_token_enable: s.mm_token_enable.unwrap_or(0),
        mm_token_bind: s.mm_token_bind.unwrap_or(0),
    };
    format.print_rows(&rows, &[json])?;
    Ok(())
}

// ===================================================================
// v1.4.98 T2-2 (mobile-source-audit Phase 2): risk-free rate
// CMD 20231 GetRiskFreeRate (无加密)
// ===================================================================

#[derive(serde::Serialize, tabled::Tabled)]
struct RiskFreeRateRow {
    market: String,
    /// 利率 (百分比数值, e.g. 4.5 表示 4.5%)
    rate_pct: String,
    /// raw uint64 (×10^9)
    raw: u64,
}

#[derive(serde::Serialize)]
struct RiskFreeRateJson {
    hk_rate_pct: Option<f64>,
    us_rate_pct: Option<f64>,
    jp_rate_pct: Option<f64>,
    update_time: Option<i64>,
    hk_rate_raw: Option<u64>,
    us_rate_raw: Option<u64>,
    jp_rate_raw: Option<u64>,
}

pub async fn run_risk_free_rate(gateway: &str, format: OutputFormat) -> Result<()> {
    use futu_backend::proto_internal::risk_free_rate;

    let (client, _rx) = connect_gateway(gateway, "futucli-risk-free-rate").await?;
    let req = risk_free_rate::DaemonGetRiskFreeRateReq {
        c2s: risk_free_rate::daemon_get_risk_free_rate_req::C2s { rate_time: None },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_GET_RISK_FREE_RATE, body)
        .await?;
    let resp = risk_free_rate::DaemonGetRiskFreeRateRsp::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode risk_free_rate: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "risk_free_rate ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    // Daemon returns percent value (4.5 means 4.5%). Internally option
    // probability uses the C++ formula unit raw / 1e9 (0.045 for 4.5%).
    let fmt_pct = |v: Option<f64>| -> String {
        match v {
            Some(p) => format!("{:.4}%", p),
            None => "—".into(),
        }
    };
    let rows = vec![
        RiskFreeRateRow {
            market: "HK".into(),
            rate_pct: fmt_pct(s.hk_rate_pct),
            raw: s.hk_rate_raw.unwrap_or(0),
        },
        RiskFreeRateRow {
            market: "US".into(),
            rate_pct: fmt_pct(s.us_rate_pct),
            raw: s.us_rate_raw.unwrap_or(0),
        },
        RiskFreeRateRow {
            market: "JP".into(),
            rate_pct: fmt_pct(s.jp_rate_pct),
            raw: s.jp_rate_raw.unwrap_or(0),
        },
    ];
    let json = RiskFreeRateJson {
        hk_rate_pct: s.hk_rate_pct,
        us_rate_pct: s.us_rate_pct,
        jp_rate_pct: s.jp_rate_pct,
        update_time: s.update_time,
        hk_rate_raw: s.hk_rate_raw,
        us_rate_raw: s.us_rate_raw,
        jp_rate_raw: s.jp_rate_raw,
    };
    format.print_rows(&rows, &[json])?;
    Ok(())
}

// ===================================================================
// v1.4.98 T2-1: SpreadTable cmd 6503
// ===================================================================

pub async fn run_spread_table(gateway: &str, format: OutputFormat) -> Result<()> {
    use futu_backend::proto_internal::spread_table_6503;

    let (client, _rx) = connect_gateway(gateway, "futucli-spread-table").await?;
    let req = spread_table_6503::DaemonGetSpreadTableReq {
        c2s: spread_table_6503::daemon_get_spread_table_req::C2s { reserved: None },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_GET_SPREAD_TABLE, body)
        .await?;
    let resp = spread_table_6503::DaemonGetSpreadTableRsp::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode spread_table: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "spread_table ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    // 直接 JSON dump (table 格式不适合多层嵌套 list, 用 json/raw 输出)
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    match format {
        // v1.4.99 codex F4 fix (P2, 2026-04-27): Jsonl 之前 fall through 到
        // table branch (人类可读). 改为 Json/Jsonl 都走结构化 (jsonl =
        // 紧凑单行, json = pretty multiline). pitfall #37 4-place sync.
        OutputFormat::Json => println!("{}", serde_json::to_string_pretty(&s)?),
        OutputFormat::Jsonl => println!("{}", serde_json::to_string(&s)?),
        OutputFormat::Table => {
            // table 格式: 摘要 (spread_code, item count)
            println!(
                "Spread tables: {} (use --output json for full data)",
                s.spread_table_list.len()
            );
            for t in &s.spread_table_list {
                println!(
                    "  spread_code={:?}  items={}",
                    t.spread_code,
                    t.spread_item_list.len()
                );
            }
        }
    }
    Ok(())
}

// ===================================================================
// v1.4.98 T2-3: TickerStatistic cmd 6365
// ===================================================================

pub async fn run_ticker_statistic(
    gateway: &str,
    symbol: &str,
    ticker_type: Option<i32>,
    stat_type: Option<u32>,
    format: OutputFormat,
) -> Result<()> {
    use futu_backend::proto_internal::ticker_statistic_daemon;

    let (client, _rx) = connect_gateway(gateway, "futucli-ticker-statistic").await?;
    // codex 2026-04-27 P3 fix: 复用 crate::common::parse_symbol (与 MCP /
    // 其他 CLI quote 命令同 parser, 大小写不敏感 + HK_FUTURE 支持) 而非
    // 本地手写 case-sensitive 4-market match.
    let sec = crate::common::parse_symbol(symbol)?;
    let req = ticker_statistic_daemon::DaemonGetTickerStatisticReq {
        c2s: ticker_statistic_daemon::daemon_get_ticker_statistic_req::C2s {
            security: ticker_statistic_daemon::Security {
                market: sec.market as i32,
                code: sec.code,
            },
            ticker_type,
            ticker_time: None,
            stat_type,
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_GET_TICKER_STATISTIC, body)
        .await?;
    let resp = ticker_statistic_daemon::DaemonGetTickerStatisticRsp::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode ticker_statistic: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "ticker_statistic ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    match format {
        // v1.4.99 codex F4 fix (P2, 2026-04-27): same as SpreadTable —
        // Jsonl 走结构化, 不 fall through 到 table.
        OutputFormat::Json => println!("{}", serde_json::to_string_pretty(&s)?),
        OutputFormat::Jsonl => println!("{}", serde_json::to_string(&s)?),
        OutputFormat::Table => {
            println!("symbol: {}", symbol);
            if let Some(stid) = s.resolved_stock_id {
                println!("resolved_stock_id: {}", stid);
            }
            if let Some(tt) = s.ticker_time {
                println!("ticker_time: {}", tt);
            }
            if !s.date_list.is_empty() {
                println!("date_list (returned when ticker_time=0): {:?}", s.date_list);
            }
            if let Some(stat) = &s.stat {
                println!("avg_price: {:?}", stat.avg_price);
                println!("trade_volume: {:?}", stat.trade_volume);
                println!("trade_num: {:?}", stat.trade_num);
                println!("buy_volume: {:?}", stat.buy_volume);
                println!("sell_volume: {:?}", stat.sell_volume);
                println!("neutral_volume: {:?}", stat.neutral_volume);
                println!("last_close_price: {:?}", stat.last_close_price);
            }
        }
    }
    Ok(())
}

// ===================================================================
// v1.4.106 codex 0500 ζ23-redo: TickerStatistic Detail cmd 6366
// ===================================================================

pub struct TickerStatisticDetailCommand<'a> {
    pub gateway: &'a str,
    pub symbol: &'a str,
    pub ticker_type: Option<i32>,
    pub ticker_time: Option<u64>,
    pub select_num: Option<u32>,
    pub data_from: Option<u32>,
    pub data_max_count: Option<u32>,
    pub stat_type: Option<u32>,
    pub format: OutputFormat,
}

pub async fn run_ticker_statistic_detail(input: TickerStatisticDetailCommand<'_>) -> Result<()> {
    use futu_backend::proto_internal::ticker_statistic_daemon;

    let (client, _rx) = connect_gateway(input.gateway, "futucli-ticker-statistic-detail").await?;
    let sec = crate::common::parse_symbol(input.symbol)?;
    let req = ticker_statistic_daemon::DaemonGetTickerStatisticDetailReq {
        c2s: ticker_statistic_daemon::daemon_get_ticker_statistic_detail_req::C2s {
            security: ticker_statistic_daemon::Security {
                market: sec.market as i32,
                code: sec.code,
            },
            ticker_type: input.ticker_type,
            ticker_time: input.ticker_time,
            select_num: input.select_num,
            data_from: input.data_from,
            data_max_count: input.data_max_count,
            stat_type: input.stat_type,
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_GET_TICKER_STATISTIC_DETAIL, body)
        .await?;
    let resp =
        ticker_statistic_daemon::DaemonGetTickerStatisticDetailRsp::decode(frame.body.as_ref())
            .map_err(|e| anyhow!("decode ticker_statistic_detail: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "ticker_statistic_detail ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    match input.format {
        OutputFormat::Json => println!("{}", serde_json::to_string_pretty(&s)?),
        OutputFormat::Jsonl => println!("{}", serde_json::to_string(&s)?),
        OutputFormat::Table => {
            println!("symbol: {}", input.symbol);
            if let Some(stid) = s.resolved_stock_id {
                println!("resolved_stock_id: {}", stid);
            }
            if let Some(tt) = s.ticker_time {
                println!("ticker_time: {}", tt);
            }
            if let Some(have_more) = s.have_more {
                println!("have_more: {}", have_more);
            }
            if let Some(mr) = s.max_ratio {
                println!("max_ratio: {:.5}", mr);
            }
            println!("items ({}):", s.items.len());
            for (i, item) in s.items.iter().enumerate() {
                println!(
                    "  [{:2}] price={:?} buy={:?} sell={:?} vol={:?} ratio={:?} neutral={:?}",
                    i,
                    item.price,
                    item.buy_volume,
                    item.sell_volume,
                    item.volume,
                    item.ratio,
                    item.neutral_volume
                );
            }
        }
    }
    Ok(())
}