futucli/cmd/

trade_ext.rs

//! `futucli` 交易扩展命令（v1.4.25）：place-order / modify-order /
//! cancel-order / reconfirm-order / history-orders / history-deals / max-qtys
//!
//! 设计原则：
//! - **place-order 强制 `--confirm`**：防误操作 / 防复制粘贴事故
//! - **所有命令要求 gateway 已 unlock**（写操作路径，network 路径里会 err）
//! - **sim 环境默认**：env 没显式传时**默认 simulate**，减少实盘误触
//! - **表格输出 + JSON 输出双栈**：和现有 `account.rs` 一致
//!
//! 对齐 Futu 官方 Python SDK（`FutunnOpen/py-futu-api`）：
//! - place-order → `OpenTradeContext.place_order`
//! - modify-order → `OpenTradeContext.modify_order`
//! - cancel-order → `OpenTradeContext.modify_order(op=CANCEL)`
//! - reconfirm-order → `OpenTradeContext.reconfirm_order`
//! - history-orders → `OpenTradeContext.history_order_list_query`
//! - history-deals → `OpenTradeContext.history_deal_list_query`
//! - max-qtys → `OpenTradeContext.acctradinginfo_query`

use anyhow::{Context, Result, bail};

use crate::cmd::account::{parse_trd_env, parse_trd_market_for_write};
use crate::common::connect_gateway;
use crate::output::OutputFormat;

mod cash_flow;
mod hints;
mod history;
mod idempotency;
mod margin_fee;
mod max_qtys;
mod parsers;
mod write_output;

#[cfg(test)]
mod tests;

pub use cash_flow::{AccCashFlowRangeCommand, run_acc_cash_flow, run_acc_cash_flow_range};
pub use history::{
    HistoryDealsCommand, HistoryOrdersCommand, run_history_deals, run_history_orders,
};
pub use margin_fee::{run_margin_ratio, run_order_fee};
pub use max_qtys::{MaxQtysCommand, run_max_qtys};

#[cfg(test)]
pub(crate) use cash_flow::acc_cash_flow_advance_day;
pub(crate) use hints::emit_trade_hint_if_known;
#[cfg(test)]
pub(crate) use hints::translate_trade_ret_msg;
#[cfg(test)]
pub(crate) use history::validate_history_time_range;
pub(crate) use idempotency::{IdempotencyParams, resolve_auto_idempotency_key};
pub(crate) use parsers::{
    parse_modify_op, parse_numeric_order_id_arg, parse_order_type, parse_trd_side,
    resolve_order_id_arg,
};
#[cfg(test)]
pub(crate) use write_output::render_trade_write_success;
pub(crate) use write_output::{TradeWriteSuccess, emit_trade_write_success};

use futu_trd::misc::reconfirm_order;
use futu_trd::order::{modify_order, place_order};
use futu_trd::types::{ModifyOrderOp, ModifyOrderParams, PlaceOrderParams, TrdEnv, TrdHeader};

// ===== place-order =====

pub struct PlaceOrderCommand<'a> {
    pub gateway: &'a str,
    pub env: &'a str,
    pub acc_id: u64,
    pub market: &'a str,
    pub side: &'a str,
    pub order_type: &'a str,
    pub code: &'a str,
    pub qty: f64,
    pub price: Option<f64>,
    pub jp_acc_type: Option<i32>,
    pub confirm: bool,
    pub idempotency_key: Option<String>,
    // v1.4.53 F1 条件单字段
    pub stop_price: Option<f64>,
    pub trail_type: Option<i32>,
    pub trail_value: Option<f64>,
    pub trail_spread: Option<f64>,
    pub output: OutputFormat,
}

pub async fn run_place_order(input: PlaceOrderCommand<'_>) -> Result<()> {
    // v1.4.41 P3.6 修: auto key 从 random UUID 改成参数 hash（deterministic）
    let idempotency_key = resolve_auto_idempotency_key(
        input.idempotency_key,
        &IdempotencyParams {
            acc_id: input.acc_id,
            market: input.market,
            code: input.code,
            side: input.side,
            qty: input.qty,
            price: input.price,
            order_type: input.order_type,
        },
    );
    let env_p = parse_trd_env(input.env)?;
    let market_p = parse_trd_market_for_write(input.market)?;
    let side_p = parse_trd_side(input.side)?;
    let order_type_p = parse_order_type(input.order_type)?;

    // 安全闸：real env 必须 --confirm，防复制粘贴事故
    if matches!(env_p, TrdEnv::Real) && !input.confirm {
        bail!(
            "real-env place_order requires --confirm for safety. \
             Re-run with --confirm after double-checking all params. \
             (Or use --env simulate for paper trading.)"
        );
    }

    let placing_msg = format!(
        "placing {} {:?} × {} @ {} {:?} (env={:?}, acc={}, market={:?}, code={})",
        input.order_type,
        side_p,
        input.qty,
        input.price.unwrap_or(0.0),
        order_type_p,
        env_p,
        input.acc_id,
        market_p,
        input.code
    );
    if matches!(input.output, OutputFormat::Table) {
        println!("{placing_msg}");
    } else {
        eprintln!("{placing_msg}");
    }

    let params = PlaceOrderParams {
        header: TrdHeader {
            trd_env: env_p,
            acc_id: input.acc_id,
            trd_market: market_p,
            jp_acc_type: input.jp_acc_type,
        },
        trd_side: side_p,
        order_type: order_type_p,
        code: input.code.to_string(),
        qty: input.qty,
        price: input.price,
        adjust_price: None,
        adjust_side_and_limit: None,
        idempotency_key,
        // v1.4.53 F1 条件单
        aux_price: input.stop_price,
        trail_type: input.trail_type,
        trail_value: input.trail_value,
        trail_spread: input.trail_spread,
    };

    let (client, _push_rx) = connect_gateway(input.gateway, "futucli-place-order")
        .await
        .context("connect gateway")?;
    // v1.4.92 D1: 错误时尽量给用户 actionable hint（不改 error chain，纯增量 stderr）
    let result = match place_order(&client, &params).await {
        Ok(r) => r,
        Err(e) => {
            let wrapped = anyhow::Error::from(e).context("place_order RPC");
            emit_trade_hint_if_known(&wrapped);
            return Err(wrapped);
        }
    };

    emit_trade_write_success(
        input.output,
        TradeWriteSuccess {
            operation: "place_order",
            order_id: result.order_id,
            returned_order_id: None,
        },
    )?;
    if matches!(input.output, OutputFormat::Table) {
        println!(
            "   (use `futucli order --market {} --acc-id {} --env {}` to verify)",
            input.market, input.acc_id, input.env
        );
    }
    Ok(())
}

// ===== modify-order / cancel-order =====

pub struct ModifyOrderCommand<'a> {
    pub gateway: &'a str,
    pub env: &'a str,
    pub acc_id: u64,
    pub market: &'a str,
    pub order_id: String,
    pub op: &'a str,
    pub qty: Option<f64>,
    pub price: Option<f64>,
    pub jp_acc_type: Option<i32>,
    pub confirm: bool,
    pub idempotency_key: Option<String>,
    pub output: OutputFormat,
}

pub async fn run_modify_order(input: ModifyOrderCommand<'_>) -> Result<()> {
    let resolved_order_id = resolve_order_id_arg(&input.order_id)?;
    // v1.4.41 P3.6 修: ModifyOrder auto key 用 (acc_id, order_id, op, qty, price) hash
    // market 和 order_id 组合已经 deterministic
    let idempotency_key = resolve_auto_idempotency_key(
        input.idempotency_key,
        &IdempotencyParams {
            acc_id: input.acc_id,
            market: input.market,
            code: "",       // modify 不用 code
            side: input.op, // op 作 side 字段（反正进 hash）
            qty: input.qty.unwrap_or(0.0),
            price: input.price,
            order_type: &resolved_order_id.idempotency_component, // 用订单身份作差异源
        },
    );
    let env_p = parse_trd_env(input.env)?;
    let market_p = parse_trd_market_for_write(input.market)?;
    let op_p = parse_modify_op(input.op)?;

    if matches!(env_p, TrdEnv::Real) && !input.confirm {
        bail!("real-env modify_order requires --confirm for safety");
    }

    let params = ModifyOrderParams {
        header: TrdHeader {
            trd_env: env_p,
            acc_id: input.acc_id,
            trd_market: market_p,
            jp_acc_type: input.jp_acc_type,
        },
        order_id: resolved_order_id.order_id,
        order_id_ex: resolved_order_id.order_id_ex.clone(),
        modify_order_op: op_p,
        qty: input.qty,
        price: input.price,
        for_all: None,
        idempotency_key,
    };

    let (client, _push_rx) = connect_gateway(input.gateway, "futucli-trade-ext").await?;
    // v1.4.92 D1: 错误时尝试给 actionable hint（不改 exit code / error chain）
    let ret_order_id = match modify_order(&client, &params).await {
        Ok(r) => r,
        Err(e) => {
            let wrapped = anyhow::Error::from(e).context("modify_order RPC");
            emit_trade_hint_if_known(&wrapped);
            return Err(wrapped);
        }
    };
    emit_trade_write_success(
        input.output,
        TradeWriteSuccess {
            operation: "modify_order",
            order_id: if resolved_order_id.order_id != 0 {
                resolved_order_id.order_id
            } else {
                ret_order_id
            },
            returned_order_id: Some(ret_order_id),
        },
    )?;
    Ok(())
}

pub struct CancelOrderCommand<'a> {
    pub gateway: &'a str,
    pub env: &'a str,
    pub acc_id: u64,
    pub market: &'a str,
    pub order_id: String,
    pub jp_acc_type: Option<i32>,
    pub confirm: bool,
    pub idempotency_key: Option<String>,
    pub output: OutputFormat,
}

pub async fn run_cancel_order(input: CancelOrderCommand<'_>) -> Result<()> {
    let resolved_order_id = resolve_order_id_arg(&input.order_id)?;
    let env_p = parse_trd_env(input.env)?;
    let market_p = parse_trd_market_for_write(input.market)?;

    if matches!(env_p, TrdEnv::Real) && !input.confirm {
        bail!("real-env cancel_order requires --confirm for safety");
    }

    let header = TrdHeader {
        trd_env: env_p,
        acc_id: input.acc_id,
        trd_market: market_p,
        jp_acc_type: input.jp_acc_type,
    };
    let (client, _push_rx) = connect_gateway(input.gateway, "futucli-trade-ext").await?;
    let params = ModifyOrderParams {
        header: header.clone(),
        order_id: resolved_order_id.order_id,
        order_id_ex: resolved_order_id.order_id_ex.clone(),
        modify_order_op: ModifyOrderOp::Cancel,
        qty: None,
        price: None,
        for_all: None,
        idempotency_key: input.idempotency_key,
    };
    // v1.4.92 D1: 错误时尝试给 actionable hint
    let ret_order_id = match modify_order(&client, &params).await {
        Ok(id) => id,
        Err(e) => {
            let wrapped = anyhow::Error::from(e).context("cancel_order RPC");
            emit_trade_hint_if_known(&wrapped);
            return Err(wrapped);
        }
    };
    emit_trade_write_success(
        input.output,
        TradeWriteSuccess {
            operation: "cancel_order",
            order_id: if resolved_order_id.order_id != 0 {
                resolved_order_id.order_id
            } else {
                ret_order_id
            },
            returned_order_id: None,
        },
    )?;
    Ok(())
}

pub struct ReconfirmOrderCommand<'a> {
    pub gateway: &'a str,
    pub env: &'a str,
    pub acc_id: u64,
    pub market: &'a str,
    pub order_id: String,
    pub reason: i32,
    pub jp_acc_type: Option<i32>,
    pub confirm: bool,
    pub output: OutputFormat,
}

pub async fn run_reconfirm_order(input: ReconfirmOrderCommand<'_>) -> Result<()> {
    let parsed_order_id = parse_numeric_order_id_arg(&input.order_id, "--order-id")?;
    let env_p = parse_trd_env(input.env)?;
    let market_p = parse_trd_market_for_write(input.market)?;

    if matches!(env_p, TrdEnv::Real) && !input.confirm {
        bail!("real-env reconfirm_order requires --confirm for safety");
    }

    let header = TrdHeader {
        trd_env: env_p,
        acc_id: input.acc_id,
        trd_market: market_p,
        jp_acc_type: input.jp_acc_type,
    };
    let (client, _push_rx) = connect_gateway(input.gateway, "futucli-trade-ext").await?;
    let ret_order_id = match reconfirm_order(&client, &header, parsed_order_id, input.reason).await
    {
        Ok(id) => id,
        Err(e) => {
            let wrapped = anyhow::Error::from(e).context("reconfirm_order RPC");
            emit_trade_hint_if_known(&wrapped);
            return Err(wrapped);
        }
    };
    emit_trade_write_success(
        input.output,
        TradeWriteSuccess {
            operation: "reconfirm_order",
            order_id: parsed_order_id,
            returned_order_id: Some(ret_order_id),
        },
    )?;
    Ok(())
}

/// v1.4.30 P2: 订阅账户推送（订单/成交变更）
pub async fn run_sub_acc_push(
    gateway: &str,
    acc_ids: &[u64],
    _format: crate::output::OutputFormat,
) -> Result<()> {
    if acc_ids.is_empty() {
        bail!("need at least one acc_id");
    }
    let (client, _rx) = connect_gateway(gateway, "futucli-sub-acc-push").await?;
    futu_trd::misc::sub_acc_push(&client, acc_ids).await?;
    println!("✅ sub_acc_push ok: {acc_ids:?}");
    Ok(())
}

/// v1.4.30：全部撤单（对齐 py-futu-api `cancel_all_order`）
///
/// 原理：modify_order proto 带 `for_all=true` + `op=Cancel` + `order_id=0`。
/// `market` 为 None 时服务端按账户全市场撤（内部填 `TrdMarket::HK` 占位但
/// 不加 trd_market 约束——当前 Rust TrdHeader 必填 trd_market，所以 None
/// 时要求用户明示一个市场。真要跨市场撤，用多条命令分别撤）。
pub async fn run_cancel_all_order(
    gateway: &str,
    acc_id: u64,
    env: &str,
    market: Option<&str>,
    jp_acc_type: Option<i32>,
    confirm: bool,
    _format: crate::output::OutputFormat,
) -> Result<()> {
    let env_p = parse_trd_env(env)?;
    if matches!(env_p, TrdEnv::Real) && !confirm {
        bail!("real-env cancel_all_order requires --confirm for safety");
    }
    // trd_market 必填（底层 TrdHeader 不允许空）；default HK
    let market_p = match market {
        Some(m) => parse_trd_market_for_write(m)?,
        None => {
            bail!("--market required (HK|US|CN|HKCC); per-account all-markets cancel not wired")
        }
    };
    let header = TrdHeader {
        trd_env: env_p,
        acc_id,
        trd_market: market_p,
        jp_acc_type,
    };
    let params = ModifyOrderParams {
        header: header.clone(),
        order_id: 0,
        order_id_ex: None,
        modify_order_op: ModifyOrderOp::Cancel,
        qty: None,
        price: None,
        for_all: Some(true),
        idempotency_key: None,
    };
    let (client, _push_rx) = connect_gateway(gateway, "futucli-trade-ext").await?;
    modify_order(&client, &params).await?;
    println!(
        "✅ cancel_all_order ok: acc_id={} env={:?} market={:?}",
        acc_id, env_p, market_p
    );
    Ok(())
}