futu_backend/trade_query/

common.rs

use super::*;

use std::time::{SystemTime, UNIX_EPOCH};

use base64::Engine as _;
use rand::RngCore;

const OPEN_D_KEY_PREFIX: &str = "OD|";
const REQ_ID_RAW_LEN: usize = 24;
const REQ_ID_PREFIX: &str = "OD|";

/// v1.4.106 codex F7 (P2): 解析 backend `Order.text` 字段, 对齐 C++
/// `NNProto_Trd_Order.cpp:18-30` —— OpenD 写时把 text 包成
/// `OD|<localID>|<userRemark>`, 客户端读时反向拆出 `(local_id, user_remark)`.
///
/// **输入**:
/// - `text=Some("OD|123|hello")` → `Some((123, "hello"))`
/// - `text=Some("OD|123|")` → `Some((123, ""))` (空 remark, daemon 写侧合法)
/// - `text=Some("plain")` → `None` (非 OpenD 来源, 老订单 / 其他客户端)
/// - `text=Some("OD|abc|x")` → `None` (localID 非 u64)
/// - `text=None` → `None`
///
/// **返回 None 时 caller 应**:
/// 1. `local_id` 字段保持 `None` (无 OpenD 标识)
/// 2. `remark` 字段填**原始 text** (整段, 不剥前缀) — 用户可能用其他客户端
///    下单的 free-form remark, 不强制 OpenD 格式.
pub(super) fn parse_open_d_text(text: Option<&str>) -> Option<(u64, String)> {
    let text = text?;
    let body = text.strip_prefix(OPEN_D_KEY_PREFIX)?;
    let (id_part, remark) = body.split_once('|')?;
    let local_id: u64 = id_part.parse().ok()?;
    Some((local_id, remark.to_string()))
}

/// 解析 optional string 为 f64
pub(super) fn pf(s: &Option<String>) -> f64 {
    s.as_ref()
        .and_then(|v| v.parse::<f64>().ok())
        .unwrap_or(0.0)
}

/// 解析 optional string 为 Option<f64>
pub(super) fn pfo(s: &Option<String>) -> Option<f64> {
    s.as_ref().and_then(|v| v.parse::<f64>().ok())
}

/// 四舍五入到 2 位小数 (对齐 C++ Round(value, 2))
fn round2(v: f64) -> f64 {
    (v * 100.0).round() / 100.0
}

/// 根据交易市场返回对应的币种。
///
/// v1.4.27 修（BUG-5，加拿大同事 v1.4.26 回归测试发现）：原先 fund 子类型
/// （HK_Fund / US_Fund 等）对应的**后端原始值**和 **NN_TrdMarket 枚举**
/// 双轨值都没覆盖全，导致 fund 账户 currency fallback 到 HKD，CMD3020
/// 返 result_code=3 "unknown"。
///
/// - 后端 market 原值（来自 `FTUsrTrdAcc.Account.market`）：13=HK_Fund /
///   23=US_Fund / 24=SG_Fund 等
/// - NN_TrdMarket 枚举值（来自 auth_list）：113=HK_Fund / 123=US_Fund /
///   124=SG_Fund / 125=MY_Fund / 126=JP_Fund 等
///
/// `CachedTrdAcc.trd_market` 存的是后端原值（见 `bridge::account_to_cached`），
/// 所以下面优先覆盖后端原值；NN 值作 tolerance fallback。
pub(super) fn trd_market_to_currency(trd_market: i32) -> u32 {
    match trd_market {
        // AccountMarket / NN_TrdMarket main markets.
        1 => 1,   // HK → CURRENCY_HKD
        2 => 2,   // US → CURRENCY_USD
        3 => 3,   // CN → CURRENCY_CNH
        4 => 3,   // HKCC → CNH
        5 => 1,   // Futures fallback → HKD (caller should pass explicit currency)
        6 => 1,   // Universal fallback → HKD (caller should pass explicit currency)
        8 => 6,   // AU → AUD
        15 => 4,  // JP → JPY
        111 => 8, // MY → MYR
        112 => 7, // CA → CAD

        // Fund 子市场 —— v1.4.27 新增
        // 后端原值
        13 => 1, // HK_Fund (后端) → HKD
        22 => 2, // US_Fund (后端，旧编码)
        23 => 2, // US_Fund (后端) → USD
        24 => 5, // SG_Fund (后端) → SGD
        // NN 枚举值
        113 => 1, // NN_TrdMarket_HK_Fund → HKD
        123 => 2, // NN_TrdMarket_US_Fund → USD
        124 => 5, // NN_TrdMarket_SG_Fund → SGD
        125 => 8, // NN_TrdMarket_MY_Fund → MYR
        126 => 4, // NN_TrdMarket_JP_Fund → JPY

        // 期货 / 期权
        7 => 1,  // NN_TrdMarket_Futures 默认 HKD，具体按合约国别可能不准
        12 => 1, // HK_Fund（C++ 老枚举，保留兼容）

        _ => 1, // 默认 HKD（C++ fallback）
    }
}

pub(super) fn currency_to_fund_bond_ccy(currency: u32) -> &'static str {
    match currency {
        1 => "HKD",
        2 => "USD",
        3 => "CNY",
        4 => "JPY",
        5 => "SGD",
        6 => "AUD",
        7 => "CAD",
        8 => "MYR",
        _ => "HKD",
    }
}

pub(super) fn api_currency_to_backend(c: i32) -> Option<u32> {
    // C++ `NN_TrdCurrency_ConvC2S`
    //   FutuOpenD/Src/NNProtoCenter/Trade/_NNProto_Trd_Comm.cpp:869-901
    //
    // Public FTAPI/NN `NN_TrdCurrency` is compact:
    //   NNBase_Define_Enum.h:404-416 => AUD=6, CAD=7, MYR=8.
    // Backend CMD3020 uses `odr_sys_cmn::Currency`:
    //   odr_sys_cmn.proto:147-190 => AUD=8, CAD=16, MYR=41.
    match c {
        1 => Some(1),  // HKD
        2 => Some(2),  // USD
        3 => Some(3),  // CNH
        4 => Some(4),  // JPY
        5 => Some(5),  // SGD
        6 => Some(8),  // AUD
        7 => Some(16), // CAD
        8 => Some(41), // MYR
        _ => None,
    }
}

pub(super) fn backend_currency_to_api(c: u32) -> i32 {
    // C++ `NN_TrdCurrency_ConvS2C`
    //   FutuOpenD/Src/NNProtoCenter/Trade/_NNProto_Trd_Comm.cpp:834-867
    //
    // Do not return the raw backend enum for unknown values: C++ initializes
    // the result as `NN_TrdCurrency_Unknown` and only assigns known cases.
    match c {
        1 => 1,  // HKD
        2 => 2,  // USD
        3 => 3,  // CNH
        4 => 4,  // JPY
        5 => 5,  // SGD
        8 => 6,  // AUD
        16 => 7, // CAD
        41 => 8, // MYR
        _ => 0,
    }
}

/// 从 `fund_info_list` 构建 API `market_info_list` 的原生币种展示值。
///
/// C++ `FillFunds` 固定输出 8 个市场: HK, US, HKCC, JP, SG, AU, CA, MY
/// (`APIServer_Trd_GetFunds.cpp:196-224`)。因为 Rust 目前没有单独的
/// `(acc, currency) -> Vec<MarketFund>` cache，read-side native marketInfo
/// 继续沿用 backend `fund_info_list` 的分币种 total_asset；证券资产合计另见
/// `sum_diff_market_fund_assets_in_response_currency`，不可再从这里反推。
pub(super) fn build_market_info_list(
    fund_info_list: &[crate::proto_internal::asset_query::AccFundInfo],
) -> Vec<CachedMarketInfo> {
    use std::collections::HashMap;
    // 建立 currency → total_asset 映射
    let mut currency_assets: HashMap<i32, f64> = HashMap::new();
    for fi in fund_info_list {
        if let Some(c) = fi.currency {
            let api_currency = backend_currency_to_api(c);
            let assets = pf(&fi.total_asset);
            currency_assets.insert(api_currency, assets);
        }
    }

    // C++ 8 个预定义市场及对应币种
    // vecMarket = { HK(1), US(2), HKCC(4), JP(15), SG(6), AU(8), CA(112), MY(111) }
    let markets_currencies: [(i32, i32); 8] = [
        (1, 1),   // HK → HKD
        (2, 2),   // US → USD
        (4, 3),   // HKCC → CNH
        (15, 4),  // JP → JPY
        (6, 5),   // SG → SGD
        (8, 6),   // AU → AUD
        (112, 7), // CA → CAD
        (111, 8), // MY → MYR
    ];

    markets_currencies
        .iter()
        .map(|&(trd_market, currency)| CachedMarketInfo {
            trd_market,
            // C++ 数据层存储时有舍入，这里对齐到 2 位小数
            assets: round2(currency_assets.get(&currency).copied().unwrap_or(0.0)),
        })
        .collect()
}

/// Sum `diff_market_fund_info_list` in the response union currency.
///
/// C++ parses each backend `diff_market_fund_info_list` item into
/// `Ndt_Trd_MarketFund` only when `stock_market` maps through
/// `StockMarket2NNTrdMarket` (`NNProto_Trd_AccReal.cpp:148-158`), stores that
/// vector under the response currency (`NNProto_Trd_AccReal.cpp:541-552`), and
/// later sums all market funds from the requested currency bucket for
/// `securitiesAssets` (`APIServer_Trd_GetFunds.cpp:196-224`).
pub(super) fn sum_diff_market_fund_assets_in_response_currency(
    diff_market_fund_info_list: &[crate::proto_internal::asset_query::AccFundInfo],
) -> Option<f64> {
    if diff_market_fund_info_list.is_empty() {
        return None;
    }

    let mut sum = 0.0;
    let mut saw_valid_market = false;
    for fund_info in diff_market_fund_info_list {
        let Some(stock_market) = fund_info.stock_market else {
            continue;
        };
        let trd_market = backend_market_to_trd_market(stock_market);
        if !matches!(trd_market, 1 | 2 | 4 | 5 | 6 | 8 | 15 | 111 | 112 | 7) {
            continue;
        }
        saw_valid_market = true;
        sum += pf(&fund_info.total_asset);
    }

    saw_valid_market.then_some(sum)
}

/// Raw C++ `HashStrToU64` without Rust's numeric-id compatibility shortcut.
fn cxx_hash_str_to_u64(s: &str) -> u64 {
    // BKDR Hash (seed=131)
    let mut bkdr: u32 = 0;
    for b in s.bytes() {
        bkdr = bkdr.wrapping_mul(131).wrapping_add(u32::from(b));
    }
    bkdr &= 0x7fff_ffff;

    // AP Hash
    let mut ap: u32 = 0;
    for (i, b) in s.bytes().enumerate() {
        let byte = u32::from(b);
        ap = if (i & 1) == 0 {
            ap ^ ((ap << 7) ^ byte ^ (ap >> 3))
        } else {
            ap ^ !((ap << 11) ^ byte ^ (ap >> 5))
        };
    }

    (u64::from(bkdr) << 32) | u64::from(ap)
}

/// Create C++-shaped backend `MsgHeader.req_id`.
///
/// Ref:
/// - `FutuOpenD/Src/NNProtoCenter/Trade/_NNProto_Trd_Comm.cpp:9-23`
/// - `FutuOpenD/Src/NNProtoCenter/NNProtoCenter_Inner_Macro_Send.h:16-24`
/// - `proto-internal/odr_sys_cmn.proto:819-824`
///
/// C++ packs 8 bytes of hash plus a 16-byte random unique id, base64-encodes
/// the 24 bytes into 32 chars, then overwrites the first bytes with `OD|`.
/// Rust uses local time plus random data in the hash seed because gateway
/// translators do not carry the login server-time clock; uniqueness and the
/// OpenD/base64 wire shape are the backend contract here.
pub fn create_backend_req_id(acc_id: u64) -> String {
    let mut rng = rand::thread_rng();
    let timestamp = match SystemTime::now().duration_since(UNIX_EPOCH) {
        Ok(duration) => duration.as_secs(),
        Err(_) => 0,
    };
    let hash_seed = format!("{}{}{}", timestamp, acc_id, rng.next_u32());
    let hash = cxx_hash_str_to_u64(&hash_seed);

    let mut raw = [0u8; REQ_ID_RAW_LEN];
    raw[..8].copy_from_slice(&hash.to_le_bytes());
    rng.fill_bytes(&mut raw[8..]);

    let mut req_id = base64::engine::general_purpose::STANDARD.encode(raw);
    req_id.replace_range(0..REQ_ID_PREFIX.len(), REQ_ID_PREFIX);
    req_id
}

/// C++ `HashStrToU64` 对齐实现，用于把 backend alphanumeric order/fill id
/// 投影成 FTAPI `uint64 orderID/fillID`.
///
/// Ref:
/// - `OM/Src/OMBase/API/OMBase_API_StrHash.cpp:52-55`
/// - `OM/Src/OMBase/Define/OMBase_Define_Macro.h:169`
///
/// C++ 语义是 `MakeToU64(APHash(str), BKDRHash(str))`，即 AP hash 放低
/// 32 位，`BKDR & 0x7fffffff` 放高 32 位。纯数字 id 仍按数字直传以兼容
/// 旧 backend / 测试数据。
pub fn hash_str_to_u64(s: &str) -> u64 {
    if s.is_empty() {
        return 0;
    }
    if let Ok(n) = s.parse::<u64>() {
        return n;
    }

    cxx_hash_str_to_u64(s)
}

/// 后端 stock_market (server值) → FTAPI TrdSecMarket
/// C++ 流程: server值 → NN_TrdMarket_ConvS2C → GetTrdSecMarket
pub(super) fn backend_stock_market_to_sec_market(svr_market: u32) -> i32 {
    // 先做 NN_TrdMarket_ConvS2C (server→client) 转换
    let client_market = match svr_market {
        11 => 111,      // NN_TrdMarket_MY
        12 => 112,      // NN_TrdMarket_CA
        13 => 113,      // NN_TrdMarket_HK_Fund
        14 => 114,      // NN_TrdMarket_Fund
        15 => 15,       // NN_TrdMarket_JP (不变)
        23 => 123,      // NN_TrdMarket_US_Fund
        24 => 124,      // NN_TrdMarket_SG_Fund
        other => other, // 其他直传
    };

    // 再做 GetTrdSecMarket (client→API SecMarket)
    // API TrdSecMarket: HK=1, US=2, CN_SH=31, CN_SZ=32, SG=41, JP=51, AU=61, MY=71, CA=81
    match client_market {
        1 | 9 | 113 => 1,       // HK, Sim_HK_Option, HK_Fund → TrdSecMarket_HK
        2 | 7 | 100 | 123 => 2, // US, Sim_US_Option, Sim_US_Margin, US_Fund → TrdSecMarket_US
        3 | 4 => 31,            // CN, HKCC → TrdSecMarket_CN_SH (默认)
        6 | 124 => 41,          // SG, SG_Fund → TrdSecMarket_SG
        8 => 61,                // AU → TrdSecMarket_AU
        15 => 51,               // JP → TrdSecMarket_JP
        111 => 71,              // MY → TrdSecMarket_MY
        112 => 81,              // CA → TrdSecMarket_CA
        _ => 1,                 // 默认 HK
    }
}

/// 后端 stock_market (server值) → FTAPI TrdMarket
/// C++ 流程: server值 → NN_TrdMarket_ConvS2C → TrdMarket_NNToAPI
/// NN_TrdMarket 和 API TrdMarket 使用相同的枚举值，TrdMarket_NNToAPI 大部分直传
pub(super) fn backend_market_to_trd_market(svr_market: u32) -> i32 {
    // NN_TrdMarket_ConvS2C (Real环境)
    let client_market = match svr_market {
        11 => 111,      // MY
        12 => 112,      // CA
        13 => 113,      // HK_Fund
        14 => 114,      // Fund
        15 => 15,       // JP (不变)
        23 => 123,      // US_Fund
        24 => 124,      // SG_Fund
        other => other, // 其他直传
    };
    // TrdMarket_NNToAPI: NN_TrdMarket 和 API TrdMarket 值相同
    client_market as i32
}

#[cfg(test)]
mod tests;