futu_gateway/handlers/

mod.rs

pub mod qot;
pub mod sys;
pub mod trd;

// 通用响应构建辅助

/// 从 SharedBackend 加载当前后端连接（原子读取，支持重连后自动更新）
pub fn load_backend(
    shared: &crate::bridge::SharedBackend,
) -> Option<std::sync::Arc<futu_backend::conn::BackendConn>> {
    let guard = shared.load();
    guard.as_ref().clone()
}

/// 构建成功响应（ret_type=0, s2c 为 protobuf 编码后的 bytes）
pub fn make_success_response<M: prost::Message>(resp: &M) -> Vec<u8> {
    prost::Message::encode_to_vec(resp)
}

/// 解码后端响应 protobuf，兼容可能存在的 4 字节长度前缀
///
/// 部分后端协议（如 CMD 5120/5121）的响应可能包含 OMBinSrz 4 字节大端长度前缀，
/// 也可能是裸 protobuf。此函数先尝试裸 protobuf 解码，失败后尝试跳过前 4 字节。
pub fn decode_backend_proto<M: prost::Message + Default>(
    body: &[u8],
) -> Result<M, prost::DecodeError> {
    // 先尝试裸 protobuf 解码
    match prost::Message::decode(body) {
        Ok(m) => Ok(m),
        Err(e1) => {
            // 如果 body 长度 >= 4，尝试跳过 4 字节长度前缀
            if body.len() >= 4 {
                match prost::Message::decode(&body[4..]) {
                    Ok(m) => {
                        tracing::debug!(
                            body_len = body.len(),
                            "decoded backend proto after skipping 4-byte length prefix"
                        );
                        Ok(m)
                    }
                    Err(_) => Err(e1), // 返回原始错误
                }
            } else {
                Err(e1)
            }
        }
    }
}

/// 从 raw protobuf 中提取指定 field number 的所有 LengthDelimited 值，
/// 然后将每个值解码为 prost::Message。
/// 用于处理后端使用了不同于 proto 文件定义的 field number 的情况。
pub fn extract_repeated_field<M: prost::Message + Default>(
    body: &[u8],
    target_field: u32,
) -> Vec<M> {
    let mut results = Vec::new();
    let mut pos = 0;
    while pos < body.len() {
        // 解析 tag (varint)
        let (tag, new_pos) = match decode_varint(body, pos) {
            Some(v) => v,
            None => break,
        };
        let field_number = (tag >> 3) as u32;
        let wire_type = (tag & 0x7) as u8;

        match wire_type {
            0 => {
                // varint — skip
                match decode_varint(body, new_pos) {
                    Some((_, p)) => pos = p,
                    None => break,
                }
            }
            1 => {
                // 64-bit — skip 8 bytes
                pos = new_pos + 8;
            }
            2 => {
                // length-delimited
                let (length, data_start) = match decode_varint(body, new_pos) {
                    Some(v) => (v.0 as usize, v.1),
                    None => break,
                };
                if data_start + length > body.len() {
                    break;
                }
                if field_number == target_field {
                    if let Ok(msg) = prost::Message::decode(&body[data_start..data_start + length])
                    {
                        results.push(msg);
                    }
                }
                pos = data_start + length;
            }
            5 => {
                // 32-bit — skip 4 bytes
                pos = new_pos + 4;
            }
            _ => break,
        }
    }
    results
}

/// 从 SRPC 封装的响应体中提取 field 5 的数据并解码为指定消息类型。
/// 后端某些命令（CMD 5120/5121）的响应被 SRPC envelope 包装，实际数据在 field 5。
pub fn extract_field5_message<M: prost::Message + Default>(body: &[u8]) -> Option<M> {
    extract_field5_message_with(body, |_| true)
}

/// 从 SRPC field 5 解码消息，使用 validator 验证结果。
/// 如果 field 5 直接解码无效，还会尝试从 field 5 → field 4 提取（嵌套 SRPC）。
pub fn extract_field5_validated<M: prost::Message + Default>(
    body: &[u8],
    validator: impl Fn(&M) -> bool,
) -> Option<M> {
    extract_field5_message_with(body, validator)
}

fn extract_field5_message_with<M: prost::Message + Default>(
    body: &[u8],
    validator: impl Fn(&M) -> bool,
) -> Option<M> {
    let field5_data = extract_raw_field(body, 5)?;

    // 尝试直接解码 field 5 数据
    if let Ok(m) = prost::Message::decode(field5_data) {
        if validator(&m) {
            return Some(m);
        }
    }

    // field 5 内部可能还有嵌套封装（如 SRPC service envelope：field 1=version, field 2=service, field 4=data）
    // 尝试从 field 5 的 field 4 中提取
    if let Some(inner) = extract_raw_field(field5_data, 4) {
        if let Ok(m) = prost::Message::decode(inner) {
            if validator(&m) {
                tracing::debug!("decoded message from SRPC field 5 → inner field 4");
                return Some(m);
            }
        }
    }

    None
}

/// 从 protobuf 消息中提取指定 field number 的第一个 length-delimited 数据切片
fn extract_raw_field(body: &[u8], target_field: u32) -> Option<&[u8]> {
    let mut pos = 0;
    while pos < body.len() {
        let (tag, new_pos) = decode_varint(body, pos)?;
        let field_number = (tag >> 3) as u32;
        let wire_type = (tag & 0x7) as u8;

        match wire_type {
            0 => {
                let (_, p) = decode_varint(body, new_pos)?;
                pos = p;
            }
            1 => {
                pos = new_pos + 8;
            }
            2 => {
                let (length, data_start) = decode_varint(body, new_pos)?;
                let length = length as usize;
                if data_start + length > body.len() {
                    return None;
                }
                if field_number == target_field {
                    return Some(&body[data_start..data_start + length]);
                }
                pos = data_start + length;
            }
            5 => {
                pos = new_pos + 4;
            }
            _ => return None,
        }
    }
    None
}

fn decode_varint(body: &[u8], start: usize) -> Option<(u64, usize)> {
    let mut result: u64 = 0;
    let mut shift = 0;
    let mut pos = start;
    loop {
        if pos >= body.len() {
            return None;
        }
        let b = body[pos];
        pos += 1;
        result |= ((b & 0x7f) as u64) << shift;
        if b & 0x80 == 0 {
            return Some((result, pos));
        }
        shift += 7;
        if shift >= 64 {
            return None;
        }
    }
}

/// 统一 SRPC 封装解码：先尝试标准解码，如果结果无效则尝试 SRPC field 5 解码。
///
/// - `body`: 后端响应体
/// - `validator`: 验证解码结果是否有效的闭包。返回 true 表示结果有效，直接使用；
///   返回 false 表示结果无效，继续尝试 SRPC field 5 解码。
///
/// 适用于 CMD 5120/5121 等被 SRPC envelope 包装的后端命令。
pub fn decode_srpc_or_direct<M: prost::Message + Default>(
    body: &[u8],
    validator: impl Fn(&M) -> bool,
) -> M {
    // 1. 尝试标准解码（裸 protobuf + 跳过 4 字节前缀）
    if let Ok(r) = decode_backend_proto::<M>(body) {
        if validator(&r) {
            return r;
        }
    }

    // 2. 标准解码无效 → 从 SRPC envelope 的 field 5 提取（带 validator）
    if let Some(r) = extract_field5_validated::<M>(body, &validator) {
        tracing::debug!("decoded message from SRPC field 5");
        return r;
    }

    // 3. fallback: 返回默认值
    tracing::warn!(
        body_len = body.len(),
        "SRPC decode: all attempts returned invalid data, using default"
    );
    M::default()
}

/// 多语言名称（手动解析，不通过 prost）
#[derive(Debug, Clone)]
pub struct MultiLangName {
    pub language_id: i32,
    pub name: String,
}

/// CMD5121 专用解码：SRPC field 5 包含的是 repeated GroupInfo（不是 GetGroupListResp）。
///
/// GroupInfo 的 field 4 (multi_lang_name) 包含后端数据导致 prost 整体解码失败，
/// 因此 proto 中不定义 field 4。本函数先用 prost 解码 fields 1-3，
/// 再手动从原始字节中提取 field 4 的 MultiLanguageName。
pub fn decode_cmd5121_groups(
    body: &[u8],
) -> (
    futu_backend::proto_internal::wch_lst::GetGroupListResp,
    Vec<Vec<MultiLangName>>,
) {
    use futu_backend::proto_internal::wch_lst::{GetGroupListResp, GroupInfo};

    // 1. 尝试标准解码
    if let Ok(r) = decode_backend_proto::<GetGroupListResp>(body) {
        if r.result_code.is_some() && !r.group_list.is_empty() {
            let empty_langs = vec![vec![]; r.group_list.len()];
            return (r, empty_langs);
        }
    }

    // 2. 检查 SRPC metadata (field 3) 中的 result_code
    //    SRPC field 3 内部: field 1 = result_code (0=成功, 非0=错误)
    let srpc_ok = extract_raw_field_bytes(body, 3)
        .first()
        .and_then(|meta| {
            // meta 内部 field 1 是 varint = result_code
            let mut pos = 0;
            while pos < meta.len() {
                let (tag, new_pos) = decode_varint(meta, pos)?;
                let field_number = (tag >> 3) as u32;
                let wire_type = (tag & 0x7) as u8;
                match wire_type {
                    0 => {
                        let (val, p) = decode_varint(meta, new_pos)?;
                        if field_number == 1 {
                            return Some(val == 0);
                        }
                        pos = p;
                    }
                    2 => {
                        let (len, start) = decode_varint(meta, new_pos)?;
                        pos = start + len as usize;
                    }
                    _ => break,
                }
            }
            Some(true) // 没找到 result_code，默认成功
        })
        .unwrap_or(true);

    if !srpc_ok {
        // SRPC metadata 报错，但 field 5 可能仍然包含有效数据
        // 尝试继续解码而非直接返回空
        let meta = extract_raw_field_bytes(body, 3);
        let hex: String = meta
            .first()
            .map(|m| {
                m.iter()
                    .map(|b| format!("{b:02x}"))
                    .collect::<Vec<_>>()
                    .join(" ")
            })
            .unwrap_or_default();
        tracing::warn!(body_len = body.len(), srpc_meta_hex = %hex, "CMD5121: SRPC metadata error, trying field 5 anyway");
    }

    // 3. SRPC field 5 包含 repeated GroupInfo，用 extract_repeated_field 解码
    //    （proto 中不定义 field 4，prost 自动跳过）
    let group_list: Vec<GroupInfo> = extract_repeated_field(body, 5);
    if group_list.is_empty() {
        tracing::warn!(body_len = body.len(), "CMD5121 decode: no GroupInfo found");
        return (GetGroupListResp::default(), vec![]);
    }

    // 4. 同时提取 field 5 的原始字节，从中手动解析 field 4 (multi_lang_name)
    let raw_items: Vec<&[u8]> = extract_raw_field_bytes(body, 5);
    let lang_list: Vec<Vec<MultiLangName>> = raw_items
        .iter()
        .map(|raw| extract_multi_lang_names(raw))
        .collect();

    tracing::debug!(
        count = group_list.len(),
        "decoded GroupInfo from SRPC field 5 with multi_lang_name"
    );
    let resp = GetGroupListResp {
        result_code: Some(0),
        group_count: Some(group_list.len() as u32),
        group_list,
        max_reached: None,
    };
    (resp, lang_list)
}

/// 从 raw protobuf 中提取指定 field number 的所有 LengthDelimited 值的原始字节切片。
fn extract_raw_field_bytes(body: &[u8], target_field: u32) -> Vec<&[u8]> {
    let mut results = Vec::new();
    let mut pos = 0;
    while pos < body.len() {
        let (tag, new_pos) = match decode_varint(body, pos) {
            Some(v) => v,
            None => break,
        };
        let field_number = (tag >> 3) as u32;
        let wire_type = (tag & 0x7) as u8;

        match wire_type {
            0 => match decode_varint(body, new_pos) {
                Some((_, p)) => pos = p,
                None => break,
            },
            1 => {
                pos = new_pos + 8;
            }
            2 => {
                let (length, data_start) = match decode_varint(body, new_pos) {
                    Some(v) => (v.0 as usize, v.1),
                    None => break,
                };
                if data_start + length > body.len() {
                    break;
                }
                if field_number == target_field {
                    results.push(&body[data_start..data_start + length]);
                }
                pos = data_start + length;
            }
            5 => {
                pos = new_pos + 4;
            }
            _ => break,
        }
    }
    results
}

/// 从 GroupInfo 原始字节中手动提取 field 4 (repeated MultiLanguageName)。
///
/// MultiLanguageName = { optional int32 language_id = 1; optional string name = 2; }
/// 由于后端数据可能导致 prost 解码失败，这里用容错方式手动解析。
fn extract_multi_lang_names(group_info_bytes: &[u8]) -> Vec<MultiLangName> {
    let mut results = Vec::new();

    // 提取所有 field 4 的 length-delimited 数据
    let raw_items = extract_raw_field_bytes(group_info_bytes, 4);

    for raw in raw_items {
        // 手动解析 MultiLanguageName: field 1 = language_id (varint), field 2 = name (string)
        let mut language_id: i32 = 0;
        let mut name = String::new();
        let mut pos = 0;

        while pos < raw.len() {
            let (tag, new_pos) = match decode_varint(raw, pos) {
                Some(v) => v,
                None => break,
            };
            let field_number = (tag >> 3) as u32;
            let wire_type = (tag & 0x7) as u8;

            match wire_type {
                0 => {
                    // varint
                    let (val, p) = match decode_varint(raw, new_pos) {
                        Some(v) => v,
                        None => break,
                    };
                    if field_number == 1 {
                        language_id = val as i32;
                    }
                    pos = p;
                }
                1 => {
                    pos = new_pos + 8;
                }
                2 => {
                    let (length, data_start) = match decode_varint(raw, new_pos) {
                        Some(v) => (v.0 as usize, v.1),
                        None => break,
                    };
                    if data_start + length > raw.len() {
                        break;
                    }
                    if field_number == 2 {
                        name = String::from_utf8_lossy(&raw[data_start..data_start + length])
                            .to_string();
                    }
                    pos = data_start + length;
                }
                5 => {
                    pos = new_pos + 4;
                }
                _ => break,
            }
        }

        if !name.is_empty() {
            results.push(MultiLangName { language_id, name });
        }
    }

    results
}

/// 辅助函数：将字节切片转为 hex 预览字符串（最多显示 max_bytes 字节）
#[allow(dead_code)]
fn hex_preview(data: &[u8], max_bytes: usize) -> String {
    let show = &data[..data.len().min(max_bytes)];
    let hex: String = show
        .iter()
        .map(|b| format!("{:02x}", b))
        .collect::<Vec<_>>()
        .join(" ");
    if data.len() > max_bytes {
        format!("{}... ({} bytes total)", hex, data.len())
    } else {
        hex
    }
}

/// 构建错误响应
pub fn make_error_response(ret_type: i32, msg: &str) -> Vec<u8> {
    let resp = futu_proto::init_connect::Response {
        ret_type,
        ret_msg: Some(msg.to_string()),
        err_code: None,
        s2c: None,
    };
    prost::Message::encode_to_vec(&resp)
}