futucli/cmd/analysis/

market_plate.rs

//! v1.4.110+ split (from cmd/analysis.rs): market_plate domain.
//!
//! pub items: run_market_state,run_owner_plate,run_reference.

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

use crate::common::{connect_gateway, format_symbol, parse_symbol};
use crate::output::OutputFormat;
use crate::qot_sdk_adapter;

// ============================================================
// market-state
// ============================================================

#[derive(Tabled)]
struct MarketStateRow {
    #[tabled(rename = "Symbol")]
    symbol: String,
    #[tabled(rename = "Name")]
    name: String,
    #[tabled(rename = "State")]
    state: String,
}

#[derive(Serialize)]
struct MarketStateJson {
    symbol: String,
    name: String,
    market_state: i32,
}

// Market-state display labels live in futu-core; this command keeps only
// surface formatting and backend calls.
use futu_core::market::qot_market_state_label as market_state_label;

fn market_state_symbol(sec: &futu_proto::qot_common::Security) -> String {
    let sec = qot_sdk_adapter::security_from_proto(sec);
    format_symbol(&sec)
}

pub async fn run_market_state(
    gateway: &str,
    symbols: &[String],
    format: OutputFormat,
) -> Result<()> {
    if symbols.is_empty() {
        bail!("no symbols");
    }
    let (client, _rx) = connect_gateway(gateway, "futucli-market-state").await?;

    let secs: Vec<_> = symbols
        .iter()
        .map(|s| parse_symbol(s))
        .collect::<Result<Vec<_>>>()?;
    let sec_protos: Vec<_> = secs
        .iter()
        .map(|s| futu_proto::qot_common::Security {
            market: s.market as i32,
            code: s.code.clone(),
        })
        .collect();

    let req = futu_proto::qot_get_market_state::Request {
        c2s: futu_proto::qot_get_market_state::C2s {
            security_list: sec_protos,
            header: None,
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_GET_MARKET_STATE, body)
        .await?;
    let resp = futu_proto::qot_get_market_state::Response::decode(frame.body.as_ref())?;
    if resp.ret_type != 0 {
        bail!("market_state ret_type={}", resp.ret_type);
    }
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;

    let rows: Vec<MarketStateRow> = s
        .market_info_list
        .iter()
        .map(|m| MarketStateRow {
            symbol: market_state_symbol(&m.security),
            name: m.name.clone(),
            state: format!(
                "{} ({})",
                market_state_label(m.market_state),
                m.market_state
            ),
        })
        .collect();

    let jsons: Vec<MarketStateJson> = s
        .market_info_list
        .iter()
        .map(|m| MarketStateJson {
            symbol: market_state_symbol(&m.security),
            name: m.name.clone(),
            market_state: m.market_state,
        })
        .collect();

    format.print_rows(&rows, &jsons)?;
    Ok(())
}

#[cfg(test)]
mod tests;

// ============================================================
// owner-plate
// ============================================================

#[derive(Tabled)]
struct OwnerPlateRow {
    #[tabled(rename = "Symbol")]
    symbol: String,
    #[tabled(rename = "Plate")]
    plate: String,
    #[tabled(rename = "Name")]
    name: String,
    #[tabled(rename = "Type")]
    plate_type: String,
}

#[derive(Serialize)]
struct OwnerPlateJson {
    symbol: String,
    plate_code: String,
    plate_name: String,
    plate_type: i32,
}

fn plate_type_label(t: i32) -> &'static str {
    match t {
        1 => "Industry",
        2 => "Region",
        3 => "Concept",
        4 => "Other",
        _ => "Unknown",
    }
}

pub async fn run_owner_plate(
    gateway: &str,
    symbols: &[String],
    format: OutputFormat,
) -> Result<()> {
    if symbols.is_empty() {
        bail!("no symbols");
    }
    let (client, _rx) = connect_gateway(gateway, "futucli-owner-plate").await?;
    let secs: Vec<_> = symbols
        .iter()
        .map(|s| parse_symbol(s))
        .collect::<Result<Vec<_>>>()?;

    let s2c = futu_qot::market_misc::get_owner_plate(&client, &secs).await?;

    let mut rows: Vec<OwnerPlateRow> = Vec::new();
    let mut jsons: Vec<OwnerPlateJson> = Vec::new();
    for entry in &s2c.owner_plate_list {
        let sym = format!("{}.{}", entry.security.market, entry.security.code);
        for p in &entry.plate_info_list {
            rows.push(OwnerPlateRow {
                symbol: sym.clone(),
                plate: p.plate.code.clone(),
                name: p.name.clone(),
                plate_type: format!(
                    "{} ({})",
                    plate_type_label(p.plate_type.unwrap_or(0)),
                    p.plate_type.unwrap_or(0)
                ),
            });
            jsons.push(OwnerPlateJson {
                symbol: sym.clone(),
                plate_code: p.plate.code.clone(),
                plate_name: p.name.clone(),
                plate_type: p.plate_type.unwrap_or(0),
            });
        }
    }

    format.print_rows(&rows, &jsons)?;
    Ok(())
}

// ============================================================
// reference
// ============================================================

#[derive(Tabled)]
struct ReferenceRow {
    #[tabled(rename = "Code")]
    code: String,
    #[tabled(rename = "Name")]
    name: String,
    #[tabled(rename = "Lot")]
    lot_size: i32,
    #[tabled(rename = "Type")]
    sec_type: i32,
}

#[derive(Serialize)]
struct ReferenceJson {
    code: String,
    name: String,
    lot_size: i32,
    sec_type: i32,
}

fn parse_reference_type(s: &str) -> Result<i32> {
    match s.trim().to_ascii_lowercase().as_str() {
        "warrant" => Ok(1),
        "future" | "futures" => Ok(2),
        // 保持和 MCP 当前能力边界一致：backend 对 option 不支持，option 用 option-chain。
        "option" | "options" => bail!(
            "reference type option is not supported by backend; use futucli option-chain instead"
        ),
        other => bail!("unknown reference type {other:?}; use warrant|future"),
    }
}

pub async fn run_reference(
    gateway: &str,
    symbol: &str,
    reference_type: &str,
    format: OutputFormat,
) -> Result<()> {
    let sec = parse_symbol(symbol)?;
    let ref_type = parse_reference_type(reference_type)?;
    let (client, _rx) = connect_gateway(gateway, "futucli-reference").await?;
    let list = futu_qot::market_misc::get_reference(&client, &sec, ref_type).await?;

    let rows: Vec<ReferenceRow> = list
        .iter()
        .map(|s| ReferenceRow {
            code: s.security.code.clone(),
            name: s.name.clone(),
            lot_size: s.lot_size,
            sec_type: s.sec_type,
        })
        .collect();
    let jsons: Vec<ReferenceJson> = list
        .iter()
        .map(|s| ReferenceJson {
            code: s.security.code.clone(),
            name: s.name.clone(),
            lot_size: s.lot_size,
            sec_type: s.sec_type,
        })
        .collect();

    format.print_rows(&rows, &jsons)?;
    Ok(())
}