futucli/cmd/analysis/

info.rs

//! v1.4.110+ split (from cmd/analysis.rs): info domain.
//!
//! pub items: run_future_info, run_stock_filter, run_option_chain, run_history_kl_quota.

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

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

use super::option_args::{OptionChainGreekFilterArgs, OptionChainJson, OptionChainRow};
use super::trading::parse_qot_market;

#[derive(Tabled)]
struct FutureRow {
    #[tabled(rename = "Code")]
    code: String,
    #[tabled(rename = "Name")]
    name: String,
    #[tabled(rename = "Type")]
    contract_type: String,
    #[tabled(rename = "Size")]
    size: String,
    #[tabled(rename = "Last Trade")]
    last_trade: String,
}

#[derive(Serialize)]
struct FutureJson {
    code: String,
    name: String,
    contract_type: String,
    contract_size: f64,
    last_trade_time: String,
}

pub async fn run_future_info(
    gateway: &str,
    symbols: &[String],
    format: OutputFormat,
) -> Result<()> {
    if symbols.is_empty() {
        bail!("no symbols");
    }
    let secs: Vec<_> = symbols
        .iter()
        .map(|s| parse_symbol(s))
        .collect::<Result<Vec<_>>>()?;
    let (client, _rx) = connect_gateway(gateway, "futucli-future-info").await?;
    let proto_secs: 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_future_info::Request {
        c2s: futu_proto::qot_get_future_info::C2s {
            security_list: proto_secs,
            header: None,
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_GET_FUTURE_INFO, body)
        .await?;
    let resp = futu_proto::qot_get_future_info::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode future_info: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "future_info ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s2c = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let mut rows = Vec::new();
    let mut jsons = Vec::new();
    for f in &s2c.future_info_list {
        rows.push(FutureRow {
            code: f.security.code.clone(),
            name: f.name.clone(),
            contract_type: f.contract_type.clone(),
            size: format!("{:.2}", f.contract_size),
            last_trade: f.last_trade_time.clone(),
        });
        jsons.push(FutureJson {
            code: f.security.code.clone(),
            name: f.name.clone(),
            contract_type: f.contract_type.clone(),
            contract_size: f.contract_size,
            last_trade_time: f.last_trade_time.clone(),
        });
    }
    format.print_rows(&rows, &jsons)?;
    Ok(())
}

#[derive(Tabled)]
struct StockFilterRow {
    #[tabled(rename = "Code")]
    code: String,
    #[tabled(rename = "Name")]
    name: String,
}

#[derive(Serialize)]
struct StockFilterJson {
    code: String,
    name: String,
}

pub async fn run_stock_filter(
    gateway: &str,
    market: &str,
    begin: i32,
    num: i32,
    format: OutputFormat,
) -> Result<()> {
    // v1.4.111 codex: 不静默 clamp num. 越界 (begin<0 / num∉[0, 200])
    // 走 Err; num=0 对齐 C++ 作为合法空页请求.
    let bounds = futu_qot::page_bounds::validate_begin_num(begin, num, 200, "stock_filter")
        .map_err(|e| anyhow!("{}", e))?;
    let m = parse_qot_market(market)?;
    let (client, _rx) = connect_gateway(gateway, "futucli-stock-filter").await?;
    let req = futu_proto::qot_stock_filter::Request {
        c2s: futu_proto::qot_stock_filter::C2s {
            begin: bounds.begin,
            num: bounds.num,
            market: m,
            plate: None,
            base_filter_list: vec![],
            accumulate_filter_list: vec![],
            financial_filter_list: vec![],
            pattern_filter_list: vec![],
            custom_indicator_filter_list: vec![],
            header: None,
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_STOCK_FILTER, body)
        .await?;
    let resp = futu_proto::qot_stock_filter::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode stock_filter: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "stock_filter ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s2c = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let mut rows = Vec::new();
    let mut jsons = Vec::new();
    for d in &s2c.data_list {
        rows.push(StockFilterRow {
            code: d.security.code.clone(),
            name: d.name.clone(),
        });
        jsons.push(StockFilterJson {
            code: d.security.code.clone(),
            name: d.name.clone(),
        });
    }
    format.print_rows(&rows, &jsons)?;
    Ok(())
}

pub async fn run_option_chain(
    gateway: &str,
    owner: &str,
    begin: &str,
    end: &str,
    option_type_str: &str,
    greek_filter: OptionChainGreekFilterArgs,
    format: OutputFormat,
) -> Result<()> {
    let owner_sec = parse_symbol(owner)?;
    let option_type = match option_type_str.trim().to_ascii_lowercase().as_str() {
        "all" => Some(0),
        "call" => Some(1),
        "put" => Some(2),
        other => bail!("unknown option_type {other:?} (all|call|put)"),
    };
    let (client, _rx) = connect_gateway(gateway, "futucli-option-chain").await?;

    let s2c = futu_qot::market_misc::get_option_chain(
        &client,
        &owner_sec,
        begin,
        end,
        option_type,
        None,
        greek_filter.into_data_filter(),
    )
    .await?;

    let mut rows: Vec<OptionChainRow> = Vec::new();
    let mut jsons: Vec<OptionChainJson> = Vec::new();
    for entry in &s2c.option_chain {
        let mut calls: Vec<String> = Vec::new();
        let mut puts: Vec<String> = Vec::new();
        for item in &entry.option {
            if let Some(c) = &item.call {
                calls.push(c.basic.security.code.clone());
            }
            if let Some(p) = &item.put {
                puts.push(p.basic.security.code.clone());
            }
        }
        rows.push(OptionChainRow {
            strike_time: entry.strike_time.clone(),
            call_count: calls.len(),
            put_count: puts.len(),
            example_call: calls.first().cloned().unwrap_or_default(),
            example_put: puts.first().cloned().unwrap_or_default(),
        });
        jsons.push(OptionChainJson {
            strike_time: entry.strike_time.clone(),
            call_symbols: calls,
            put_symbols: puts,
        });
    }

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

// ============================================================
// v1.4.30 P2（100% 覆盖）: history-kl-quota / holding-change /
//           modify-user-security / code-change /
//           set-price-reminder / price-reminder /
//           option-expiration-date
// ============================================================

// v1.4.98 external reviewer BUG-005 fix (P2, 2026-04-27): 之前 _format 标 unused, 用户传
// `-o json` 仍打 "used: X / remain: Y" 文本. 加 format-aware output.
#[derive(serde::Serialize, tabled::Tabled)]
struct HistoryKlQuotaRow {
    field: String,
    value: String,
}

#[derive(serde::Serialize)]
struct HistoryKlQuotaJson {
    used_quota: i32,
    remain_quota: i32,
    detail_count: usize,
}

pub async fn run_history_kl_quota(gateway: &str, detail: bool, format: OutputFormat) -> Result<()> {
    let (client, _rx) = connect_gateway(gateway, "futucli-hist-kl-quota").await?;
    let req = futu_proto::qot_request_history_kl_quota::Request {
        c2s: futu_proto::qot_request_history_kl_quota::C2s {
            b_get_detail: Some(detail),
            header: None,
        },
    };
    let body = req.encode_to_vec();
    let frame = client
        .request(futu_core::proto_id::QOT_REQUEST_HISTORY_KL_QUOTA, body)
        .await?;
    let resp = futu_proto::qot_request_history_kl_quota::Response::decode(frame.body.as_ref())
        .map_err(|e| anyhow!("decode: {e}"))?;
    if resp.ret_type != 0 {
        bail!(
            "history_kl_quota ret_type={} msg={:?}",
            resp.ret_type,
            resp.ret_msg
        );
    }
    let s = resp.s2c.ok_or_else(|| anyhow!("missing s2c"))?;
    let rows = vec![
        HistoryKlQuotaRow {
            field: "used_quota".into(),
            value: s.used_quota.to_string(),
        },
        HistoryKlQuotaRow {
            field: "remain_quota".into(),
            value: s.remain_quota.to_string(),
        },
        HistoryKlQuotaRow {
            field: "detail_count".into(),
            value: s.detail_list.len().to_string(),
        },
    ];
    let json = HistoryKlQuotaJson {
        used_quota: s.used_quota,
        remain_quota: s.remain_quota,
        detail_count: s.detail_list.len(),
    };
    format.print_rows(&rows, &[json])?;
    Ok(())
}