ek-ctp 0.1.0

//! MD/TD 双会话纯状态机(逐字对照原稿 `CtpMdApi` 243-410 与 `CtpTdApi` 411-892)。
//!
//! 设计:
//! - **`step` 单步语义**:输入一个回报事件、输出一个动作/事件向量;零线程、
//!   零时钟、零 sleep —— 原稿的 `while+sleep` 流控重试与 `EventEngine` 定时器
//!   都归上层(DESIGN.md D-FLCN/D-TIME)。
//! - **合约表共享**:原稿的模块级 `symbol_contract_map` 在这里 = 注入的
//!   `Contracts` 共享表(`Arc<Mutex<HashMap<String, ContractData>>>`),
//!   由插件层创建并分发给 MD/TD 两台机。
//! - 持仓合并、order/trade 缓冲、sysid 映射、动态查询轮转全部按原稿逐字移植。

use crate::map::{self, Mapped};
use crate::wire::{
    DepthMarketData, ErrorField, InputOrder, InputOrderAction, InstrumentField, InvestorPositionField,
    OrderField, TradeField, TradingAccountField,
};
use ek_data::constant::{Direction, Offset, OrderType, Status};
use ek_data::log::{LogData, LEVEL_ERROR, LEVEL_INFO};
use ek_data::{AccountData, ContractData, OrderData, OrderRequest, PositionData, TickData, TradeData, CancelRequest};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};

use ek_data::log::LEVEL_WARNING;

/// 合约共享表(原稿全局 `symbol_contract_map` 的进程内等价物)。
pub type Contracts = Arc<Mutex<HashMap<String, ContractData>>>;

/// 空合约表构造。
pub fn contracts_empty() -> Contracts {
    Arc::new(Mutex::new(HashMap::new()))
}

// ================ 日志 helper(等价原稿 gateway.write_log/write_error) ================

/// info 级日志。
pub fn log_info(gw: &str, msg: impl Into<String>) -> LogData {
    LogData { gateway_name: gw.to_string(), msg: msg.into(), level: LEVEL_INFO }
}

/// error 级日志(错误行自动拼"代码/信息",原稿 write_error 216-222)。
pub fn log_error_with(api_msg: &str, gw: &str, e: &ErrorField) -> LogData {
    LogData {
        gateway_name: gw.to_string(),
        msg: map::error_text(api_msg, e),
        level: LEVEL_ERROR,
    }
}

// ================ MD 行情会话(原稿 CtpMdApi) ================

/// MD 会话配置(原稿 `CtpMdApi.connect` 入参)。
#[derive(Debug, Clone, Default)]
pub struct MdConfig {
    /// 行情前置地址(原稿 connect 已补完 "tcp://" 前缀后传入)
    pub addr: String,
    /// 用户代码(行情登录用)
    pub user: String,
    /// 密码
    pub password: String,
    /// 经纪公司代码
    pub broker: String,
}

/// MD 回报事件。
#[derive(Debug, Clone)]
/// MD 事件面(native 桥适配官方回报;mock 层直接喂值)。
///
/// Box 化:#[allow(clippy::large_enum_variant)] 之类抑损不是目标——本枚举
/// 只在适配线程步进,不做高频批量装箱,加 Box 反而破坏模式匹配直观性。
#[allow(clippy::large_enum_variant)]
pub enum MdEvent {
    /// onFrontConnected(265)
    FrontConnected,
    /// onFrontDisconnected(reason)(270)
    FrontDisconnected(i64),
    /// onRspUserLogin(data, error)(275)
    RspUserLogin {
        /// None = 成功
        error: Option<ErrorField>,
    },
    /// onRspError(288)
    RspError(ErrorField),
    /// onRspSubMarketData(292)
    RspSubMarketData {
        /// Some(err) = 订阅失败(error_id 非零;None 原稿 296 行两面皆静默)
        error: Option<ErrorField>,
    },
    /// onRtnDepthMarketData(301)
    RtnDepthMarketData(DepthMarketData),
}

/// MD 输出动作。
#[derive(Debug, Clone)]
/// MD 生产输出(unified 面:命令 → 传输;数据 → 总线)。
#[allow(clippy::large_enum_variant)]
pub enum MdOut {
    /// 创建/连接行情 API(原稿 connect() 368-382;flow_path 供 levefile 行情流文件
    /// 落位,原稿固定为 `{gateway_name}\Md`,native 层使用)
    ReqConnect {
        /// 行情前置地址
        addr: String,
        /// 流文件目录尾段
        flow_path: String,
    },
    /// reqUserLogin(384-393)
    ReqLogin {
        /// 用户代码
        user: String,
        /// 密码
        password: String,
        /// 经纪公司代码
        broker: String,
    },
    /// subscribeMarketData(395-399)
    ReqSubscribe(Vec<String>),
    /// 上抛行情(经 gateway.on_tick)
    Tick(TickData),
    /// 业务日志(带等级;ERROR = write_error 的形态)
    Log(LogData),
}

/// MD 状态机。
pub struct MdDriver {
    /// 网关名(日志与流文件路径的命名)
    pub gw: String,
    cfg: MdConfig,
    contracts: Contracts,
    /// 已登记的订阅集合(原稿 subscribed set;去重保序用等值判定)
    subscribed: Vec<String>,
    login_status: bool,
    connect_status: bool,
    /// 本地视角当日("YYYYMMDD";eTimer 刷新,原稿 update_date)
    current_date: String,
}

impl MdDriver {
    /// 构造(合约表注入;current_date 初值由调用方给定——原稿是 datetime.now()
    /// 的本地日期,Rust 显式化以免隐性时钟)。
    pub fn new(gw: &str, cfg: MdConfig, contracts: Contracts, current_date: String) -> Self {
        Self {
            gw: gw.to_string(),
            cfg,
            contracts,
            subscribed: Vec::new(),
            login_status: false,
            connect_status: false,
            current_date,
        }
    }

    /// eTimer 秒级刷新当日(原稿 gateway.process_timer_event 235 行调 md.update_date)。
    pub fn update_date(&mut self, date: String) {
        self.current_date = date;
    }

    /// 行情订阅入口(原稿 gateway.subscribe → md.subscribe 191-193/395-399;
    /// 登录前只登记,登录后立即发起)。
    pub fn subscribe(&mut self, symbol: &str) -> Vec<MdOut> {
        if !self.subscribed.iter().any(|s| s == symbol) {
            self.subscribed.push(symbol.to_string());
        }
        if self.login_status {
            vec![MdOut::ReqSubscribe(vec![symbol.to_string()])]
        } else {
            Vec::new()
        }
    }

    /// 连接(原稿 MD connect 368-382):首次 → 发 ReqConnect;重复调用守卫静默。
    /// close 守卫面由 `connect_status()` getter 提供(原稿 401-404)。
    pub fn connect(&mut self) -> Vec<MdOut> {
        if self.connect_status {
            return Vec::new();
        }
        self.connect_status = true;
        vec![MdOut::ReqConnect { addr: self.cfg.addr.clone(), flow_path: format!("{}\\Md", self.gw) }]
    }

    /// 步进(原型 CtpMdApi 各回调)。
    pub fn step(&mut self, ev: MdEvent) -> Vec<MdOut> {
        match ev {
            MdEvent::FrontConnected => {
                self.connect_status = true;
                vec![
                    MdOut::Log(log_info(&self.gw, "行情服务器连接成功")),
                    MdOut::ReqLogin {
                        user: self.cfg.user.clone(),
                        password: self.cfg.password.clone(),
                        broker: self.cfg.broker.clone(),
                    },
                ]
            }
            MdEvent::FrontDisconnected(reason) => {
                self.login_status = false;
                vec![MdOut::Log(log_info(&self.gw, format!("行情服务器连接断开,原因{reason}")))]
            }
            MdEvent::RspUserLogin { error } => match error {
                None => {
                    self.login_status = true;
                    let mut outs = vec![MdOut::Log(log_info(&self.gw, "行情服务器登录成功"))];
                    if !self.subscribed.is_empty() {
                        outs.push(MdOut::ReqSubscribe(self.subscribed.clone()));
                    }
                    outs
                }
                Some(e) => vec![MdOut::Log(log_error_with("行情服务器登录失败", &self.gw, &e))],
            },
            MdEvent::RspError(e) => vec![MdOut::Log(log_error_with("行情接口报错", &self.gw, &e))],
            MdEvent::RspSubMarketData { error } => match error {
                Some(e) => vec![MdOut::Log(log_error_with("行情订阅失败", &self.gw, &e))],
                None => Vec::new(),
            },
            MdEvent::RtnDepthMarketData(dm) => {
                // 合约未收录 → 静默丢(301-311)
                let contract = {
                    let m = self.contracts.lock().unwrap();
                    m.get(&dm.instrument_id).cloned()
                };
                match map::tick_from(&dm, contract.as_ref(), &self.gw, &self.current_date) {
                    Mapped::Ok(t) => vec![MdOut::Tick(t)],
                    Mapped::Skip(_) => Vec::new(),
                }
            }
        }
    }
}

// ================ TD 交易会话(原稿 CtpTdApi) ================

/// TD 会话配置(原稿 `CtpTdApi.connect` 749-777 入参)。
#[derive(Debug, Clone, Default)]
pub struct TdConfig {
    /// 交易前置地址
    pub addr: String,
    /// 用户代码
    pub user: String,
    /// 密码
    pub password: String,
    /// 经纪公司代码
    pub broker: String,
    /// 授权编码(空则跳过认证直连登录,原稿 448-451)
    pub auth_code: String,
    /// 产品名称(AppID,认证用)
    pub app_id: String,
}

/// TD 回报事件。
#[derive(Debug, Clone)]
pub enum TdEvent {
    /// onFrontConnected(445)
    FrontConnected,
    /// onFrontDisconnected(reason)(453)
    FrontDisconnected(i64),
    /// onRspAuthenticate(458-472)
    RspAuthenticate {
        /// None = 成功
        error: Option<ErrorField>,
    },
    /// onRspUserLogin(474-490)
    RspUserLogin {
        /// None = 成功
        error: Option<ErrorField>,
        /// FrontID(仅成功时有意义,原稿取 data["FrontID"])
        front_id: i64,
        /// SessionID
        session_id: i64,
    },
    /// onRspSettlementInfoConfirm(519-533)
    RspSettlementInfoConfirm {
        /// None = 成功
        error: Option<ErrorField>,
    },
    /// onRspQryInstrument(614-667)
    RspQryInstrument {
        /// 是否本包最后一笔
        last: bool,
        /// 数据行(错误包时 None)
        row: Option<InstrumentField>,
    },
    /// onRspQryInvestorPosition(535-595)
    RspQryInvestorPosition {
        /// 是否本包最后一笔
        last: bool,
        /// 数据行
        row: Option<InvestorPositionField>,
    },
    /// onRspQryTradingAccount(597-612)
    RspQryTradingAccount {
        /// 是否本包最后一笔
        last: bool,
        /// 数据行
        row: Option<TradingAccountField>,
    },
    /// onRspOrderInsert(492-513)。原稿从 err 包 OrderRef/Direction/LimitPrice 等
    /// 字段重造 REJECTED 单。
    RspOrderInsert {
        /// None = 成功受理(原稿只在 error 分支造单)
        error: Option<ErrorField>,
        /// 触发失败的报单原字段(transport 层随错误回报回带)
        req: Option<InputOrder>,
    },
    /// onRspOrderAction(515-517)
    RspOrderAction {
        /// None = 成功
        error: Option<ErrorField>,
    },
    /// onRtnOrder(669-718)
    RtnOrder(OrderField),
    /// onRtnTrade(720-747)
    RtnTrade(TradeField),
}

/// TD 输出动作。
#[derive(Debug, Clone)]
pub enum TdOut {
    /// 创建/连接交易 API(779 前流程:connect() 749-777)
    ReqConnect {
        /// 交易前置地址
        addr: String,
        /// 流文件目录尾段(`{gateway_name}\Td`)
        flow_path: String,
    },
    /// reqAuthenticate(779-792)
    ReqAuthenticate {
        /// 用户代码
        user: String,
        /// 经纪公司代码
        broker: String,
        /// 授权编码
        auth_code: String,
        /// 产品名称(AppID)
        app_id: String,
    },
    /// reqUserLogin(794-806)
    ReqLogin {
        /// 用户代码
        user: String,
        /// 密码
        password: String,
        /// 经纪公司代码
        broker: String,
    },
    /// reqSettlementInfoConfirm(482-485)
    ReqSettlementConfirm {
        /// 经纪公司代码
        broker: String,
        /// 用户代码
        user: String,
    },
    /// reqQryInstrument(合约流控重试在 transport 层,DESIGN.md D-FLCN)
    ReqQryInstrument,
    /// reqQryTradingAccount(874-877)
    ReqQryAccount {
        /// 经纪公司代码
        broker: String,
        /// 用户代码
        user: String,
    },
    /// reqQryInvestorPosition(879-887)
    ReqQryPosition {
        /// 经纪公司代码
        broker: String,
        /// 用户代码
        user: String,
    },
    /// reqOrderInsert(820-845 成功路径)
    Insert(InputOrder),
    /// reqOrderAction(856-872 成功路径)
    Cancel(InputOrderAction),
    /// 上抛合约(仅期货;经 gateway.on_contract 652)
    Contract(ContractData),
    /// 上抛订单(经 gateway.on_order)
    Order(OrderData),
    /// 上抛成交(经 gateway.on_trade)
    Trade(TradeData),
    /// 上抛持仓(合并完成;经 gateway.on_position 589-590)
    Position(PositionData),
    /// 持仓查询完成(原稿 593 行 EVENT_POSITION_QUERY_DONE;对齐 ek-oms 相位门)
    PositionQueryDone(String),
    /// 合约收齐(原稿 659 → BaseGateway.on_contract_finish → EVENT_CONTRACT_FINISH
    /// = "eContractFinish" 全局线、无 gw 后缀;载荷给网关名以便多网关辨源,D-CFIN)
    ContractFinish(String),
    /// 上抛账户(612)
    Account(AccountData),
    /// 业务日志
    Log(LogData),
}

/// 持仓 accumulator(键 = 合约 + 持仓方向码,原稿 548 的 dict key 形态)。
struct PositionAccum {
    pos: PositionData,
}

/// TD 状态机。
pub struct TdDriver {
    gw: String,
    cfg: TdConfig,
    contracts: Contracts,
    /// 请求计数(原稿 reqid;native 层使用)
    pub reqid: i64,
    /// 本地报单号计数(原稿 order_ref)
    order_ref: i64,
    /// 已连接/已登录/已认证/认证失败/登录失败/合约已收齐
    connect_status: bool,
    login_status: bool,
    auth_status: bool,
    auth_failed: bool,
    login_failed: bool,
    contract_inited: bool,
    /// FrontID(登录回报)
    front_id: i64,
    /// SessionID
    session_id: i64,
    /// 认证流程标志(驱动机;MERGED: auth 独立状态)
    /// 持仓合并缓存(原稿 positions dict;_TH 初始化面)
    positions: HashMap<String, PositionAccum>,
    /// 合约未齐时的订单缓冲(原稿 order_data;661-662)
    order_buf: Vec<OrderField>,
    /// 合约未齐时的成交缓冲(原稿 trade_data;665-667)
    trade_buf: Vec<TradeField>,
    /// OrderSysID → 本地委托号表(原稿 sysid_orderid_map;718)
    sysid_orderid: HashMap<String, String>,
    /// 查询轮转标志:[false=资金, true=持仓](原稿 query_functions 列表轮换)
    next_pos: bool,
}

impl TdDriver {
    /// 构造。
    pub fn new(gw: &str, cfg: TdConfig, contracts: Contracts) -> Self {
        Self {
            gw: gw.to_string(),
            cfg,
            contracts,
            reqid: 0,
            order_ref: 0,
            connect_status: false,
            login_status: false,
            auth_status: false,
            auth_failed: false,
            login_failed: false,
            contract_inited: false,
            front_id: 0,
            session_id: 0,
            positions: HashMap::new(),
            order_buf: Vec::new(),
            trade_buf: Vec::new(),
            sysid_orderid: HashMap::new(),
            next_pos: false,
        }
    }

    /// 本地委托号段(front_session_ref 三段下划线,原稿 495/681/850)。
    pub fn local_orderid(&self, order_ref: &str) -> String {
        format!("{}_{}_{}", self.front_id, self.session_id, order_ref)
    }

    /// 认证失败标志(63 错;原稿 auth_failed 781-782 由 authenticate 的守卫读)。
    pub fn auth_failed(&self) -> bool {
        self.auth_failed
    }

    /// 登录态(适配层复接用)。
    pub fn login_status(&self) -> bool {
        self.login_status
    }

    /// 登录失败标志(原稿 796-797 的 login 守卫,登录失败不再续发;适配层用)。
    pub fn login_failed(&self) -> bool {
        self.login_failed
    }

    /// 合约收齐标志(适配层复接用)。
    pub fn contract_inited(&self) -> bool {
        self.contract_inited
    }

    /// 当前持仓合并缓存键数(测试/适配复接用)。
    pub fn positions_len(&self) -> usize {
        self.positions.len()
    }

    /// FrontID(登录回报;适配层使用)。
    pub fn front_id(&self) -> i64 {
        self.front_id
    }

    /// 连接态(原稿 close 401-404 / 889-892 的 `if connect_status: exit()` 守卫,适配层用)。
    pub fn connect_status(&self) -> bool {
        self.connect_status
    }

    /// SessionID。
    pub fn session_id(&self) -> i64 {
        self.session_id
    }

    /// 已本地报单计数(order_ref;适配层使用)。
    pub fn order_ref(&self) -> i64 {
        self.order_ref
    }

    /// 发单(原稿 send_order 808-854)。 Returns 输出动作 + en_orderid。
    /// 校验路径原样(missings log + `""`):开平/类型缺者不放行;
    /// 方向 miss(NET)→ 空报单方向(原稿 get(...,"") 行为)。
    pub fn send_order(&mut self, req: &OrderRequest) -> SendOutcome {
        let Some(offset_code) = map::offset_to(req.offset) else {
            return SendOutcome::rejected(log_info(&self.gw, "请选择开平方向"));
        };
        let Some((price_type, time_cond, vol_cond)) = map::order_type_to(req.order_type) else {
            return SendOutcome::rejected(log_info(
                &self.gw,
                format!("当前接口不支持该类型的委托{}", req.order_type.as_str()),
            ));
        };
        self.order_ref += 1;
        let order_ref = format!("{}", self.order_ref);
        let input = InputOrder {
            instrument_id: req.symbol.clone(),
            exchange_id: req.exchange.as_str().to_string(),
            limit_price: req.price,
            volume_total_original: req.volume as i64,
            order_price_type: price_type.to_string(),
            direction: map::direction_to(req.direction).unwrap_or("").to_string(),
            comb_offset_flag: offset_code.to_string(),
            order_ref: order_ref.clone(),
            investor_id: self.cfg.user.clone(),
            user_id: self.cfg.user.clone(),
            broker_id: self.cfg.broker.clone(),
            // 830-841 固定面:投机/立即触发/非强平/不自动挂起/最小量 1
            comb_hedge_flag: "1".to_string(),
            contingent_condition: "1".to_string(),
            force_close_reason: "0".to_string(),
            is_auto_suspend: 0,
            time_condition: time_cond.to_string(),
            volume_condition: vol_cond.to_string(),
            min_volume: 1,
        };
        let orderid = self.local_orderid(&order_ref);
        // 原稿 850-852:回 SUBMITTING 单在 reqOrderInsert 送出(返回码 0)之后;
        // 返回码 n 的判定归传输层(0.1.0 由 plugin 按 trait 返回值裁决),
        // 这里只顺序产出插单命令 + SUBMITTING 单回报。
        let outs = vec![
            TdOut::Insert(input),
            TdOut::Order(req.create_order_data(&orderid, &self.gw)),
        ];
        SendOutcome::placed(outs, format!("{}.{}", self.gw, orderid))
    }

    /// 流文件目录(原稿 createFtdcTraderApi 767:`{gateway_name}\\Td`)。
    pub fn flow_path(&self) -> String {
        format!("{}\\Td", self.gw)
    }

    /// 连接(原稿 TD connect 763-777):首次 → 发 ReqConnect;**重复调用 →
    /// authenticate()**(含 auth_failed 守卫)。close 守卫面由 `connect_status()`
    /// getter 提供给适配层(原稿 889-892)。
    pub fn connect(&mut self) -> Vec<TdOut> {
        if self.connect_status {
            return self.authenticate();
        }
        self.connect_status = true;
        vec![TdOut::ReqConnect { addr: self.cfg.addr.clone(), flow_path: self.flow_path() }]
    }

    /// 认证(原稿 779-792;auth_failed 守卫 781-782 静默不重发)。
    pub fn authenticate(&mut self) -> Vec<TdOut> {
        if self.auth_failed {
            return Vec::new();
        }
        vec![TdOut::ReqAuthenticate {
            user: self.cfg.user.clone(),
            broker: self.cfg.broker.clone(),
            auth_code: self.cfg.auth_code.clone(),
            app_id: self.cfg.app_id.clone(),
        }]
    }

    /// 登录(原稿 794-806;login_failed 守卫 796-797 静默不重发)。
    pub fn login(&mut self) -> Vec<TdOut> {
        if self.login_failed {
            return Vec::new();
        }
        vec![TdOut::ReqLogin {
            user: self.cfg.user.clone(),
            password: self.cfg.password.clone(),
            broker: self.cfg.broker.clone(),
        }]
    }

    /// 撤单(原稿 cancel_order 856-872;订单号三段解析失败 → log + 放行,
    /// D6:原稿 int() 会抛 ValueError,Rust 转错误日记 + 静默)。
    pub fn cancel_order(&mut self, req: &CancelRequest) -> Vec<TdOut> {
        match map::cancel_action_from(&req.orderid, &req.symbol, req.exchange, &self.cfg.broker, &self.cfg.user) {
            Some(action) => vec![TdOut::Cancel(action)],
            None => vec![TdOut::Log(log_info(&self.gw, format!("撤单请求委托号异常:{}", req.orderid)))],
        }
    }

    /// 订单成功发光后登记 sysid 报表(707,原稿 718)。
    fn remember_sysid(&mut self, sysid: &str, orderid: &str) {
        self.sysid_orderid.insert(sysid.to_string(), orderid.to_string());
    }

    /// 查询轮转(原稿 CtpGateway.process_timer_event 224-239 + query_* 874-887;
    /// 计数器由驱动独立持有,轮转次序 = 资金 → 持仓 → 资金 …)。
    pub fn on_timer(&mut self) -> Vec<TdOut> {
        if self.next_pos {
            self.next_pos = false;
            if self.contracts.lock().unwrap().is_empty() {
                // 原稿 881-882:合约表为空 → 跳过持仓查询
                return Vec::new();
            }
            vec![TdOut::ReqQryPosition { broker: self.cfg.broker.clone(), user: self.cfg.user.clone() }]
        } else {
            self.next_pos = true;
            vec![TdOut::ReqQryAccount { broker: self.cfg.broker.clone(), user: self.cfg.user.clone() }]
        }
    }

    /// 步进(原型 CtpTdApi 各回调)。
    pub fn step(&mut self, ev: TdEvent) -> Vec<TdOut> {
        match ev {
            TdEvent::FrontConnected => {
                self.connect_status = true;
                let mut outs = vec![TdOut::Log(log_info(&self.gw, "交易服务器连接成功"))];
                // 原稿 448-451:auth_code 空 → 直登
                if self.cfg.auth_code.is_empty() {
                    outs.extend(self.login());
                } else {
                    outs.extend(self.authenticate());
                }
                outs
            }
            TdEvent::FrontDisconnected(reason) => {
                self.login_status = false;
                vec![TdOut::Log(log_info(&self.gw, format!("交易服务器连接断开,原因{reason}")))]
            }
            TdEvent::RspAuthenticate { error } => match error {
                None => {
                    self.auth_status = true;
                    vec![
                        TdOut::Log(log_info(&self.gw, "交易服务器授权验证成功")),
                        TdOut::ReqLogin {
                            user: self.cfg.user.clone(),
                            password: self.cfg.password.clone(),
                            broker: self.cfg.broker.clone(),
                        },
                    ]
                }
                Some(e) => {
                    let outs = vec![TdOut::Log(log_error_with("交易服务器授权验证失败", &self.gw, &e))];
                    if e.error_id == 63 {
                        self.auth_failed = true;
                    }
                    outs
                }
            },
            TdEvent::RspUserLogin { error, front_id, session_id } => match error {
                None => {
                    self.front_id = front_id;
                    self.session_id = session_id;
                    self.login_status = true;
                    vec![
                        TdOut::Log(log_info(&self.gw, "交易服务器登录成功")),
                        TdOut::ReqSettlementConfirm { broker: self.cfg.broker.clone(), user: self.cfg.user.clone() },
                    ]
                }
                Some(e) => {
                    self.login_failed = true;
                    vec![TdOut::Log(log_error_with("交易服务器登录失败", &self.gw, &e))]
                }
            },
            TdEvent::RspSettlementInfoConfirm { error: _ } => {
                // 原稿 523:无条件写 log;流控重试归 transport 层(D-FLCN)
                vec![
                    TdOut::Log(log_info(&self.gw, "结算信息确认成功")),
                    TdOut::ReqQryInstrument,
                ]
            }
            TdEvent::RspQryInstrument { last, row } => {
                let mut outs = Vec::new();
                if let Some(inf) = row {
                    match map::contract_from(&inf, &self.gw) {
                        Mapped::Ok(c) => {
                            // 全产品类都进共享表(654);仅期货上抛(651-652)
                            self.contracts.lock().unwrap().insert(c.symbol.clone(), c.clone());
                            if c.asset == ek_data::constant::Asset::FUTURES {
                                outs.push(TdOut::Contract(c.clone()));
                            }
                        }
                        Mapped::Skip(reason) => {
                            outs.push(TdOut::Log(LogData {
                                gateway_name: self.gw.clone(),
                                msg: format!("合约行丢弃:{}", reason),
                                level: LEVEL_WARNING,
                            }));
                        }
                    }
                }
                if last {
                    self.contract_inited = true;
                    outs.push(TdOut::Log(log_info(&self.gw, "合约信息查询成功")));
                    outs.push(TdOut::ContractFinish(self.gw.clone()));
                    let buffered_orders = std::mem::take(&mut self.order_buf);
                    for data in buffered_orders {
                        let mut sub = self.step(TdEvent::RtnOrder(data.clone()));
                        outs.append(&mut sub);
                    }
                    let buffered_trades = std::mem::take(&mut self.trade_buf);
                    for data in buffered_trades {
                        let mut sub = self.step(TdEvent::RtnTrade(data.clone()));
                        outs.append(&mut sub);
                    }
                }
                outs
            }
            TdEvent::RspQryInvestorPosition { last, row } => {
                // 原稿 539-540:data 缺 → 直接 return(空持仓查询不发事件、
                // 不冲刷、连 PositionDone 都不发;0 行与多行的末包均带 last)
                let Some(row) = row else { return Vec::new() };
                let mut outs = Vec::new();
                {
                    let contract = {
                        let m = self.contracts.lock().unwrap();
                        m.get(&row.instrument_id).cloned()
                    };
                    // 合约未收录 → 上层无库可并(原稿 543-546 同面)
                    if let Some(contract) = contract {
                        let key = format!("{}:{}", row.instrument_id, row.posi_direction);
                        let direction = map::direction_from(&row.posi_direction);
                        if !self.positions.contains_key(&key) {
                            let pos = map::new_position_data(
                                &row.instrument_id,
                                contract.exchange,
                                direction,
                                &self.gw,
                            ).unwrap_or_default();
                            self.positions.insert(key.clone(), PositionAccum { pos });
                        }
                        let entry = self.positions.get_mut(&key).expect("just inserted");
                        map::accumulate_position(&row, &mut entry.pos, contract.exchange, contract.size);
                    }
                    if last {
                        let done = self.positions.values().map(|p| p.pos.clone()).collect::<Vec<_>>();
                        for pos in done {
                            outs.push(TdOut::Position(pos));
                        }
                        outs.push(TdOut::PositionQueryDone(self.gw.clone()));
                        self.positions.clear();
                    }
                }
                outs
            }
            TdEvent::RspQryTradingAccount { last: _, row } => match row {
                Some(ta) => vec![TdOut::Account(map::account_from(&ta, &self.gw))],
                None => Vec::new(),
            },
            TdEvent::RspOrderInsert { error, req } => match (error, req) {
                (Some(e), Some(input)) => {
                    let mut outs = vec![TdOut::Log(log_error_with("交易委托失败", &self.gw, &e))];
                    let contract = {
                        let m = self.contracts.lock().unwrap();
                        m.get(&input.instrument_id).cloned()
                    };
                    if let Some(contract) = contract {
                        let orderid = self.local_orderid(&input.order_ref);
                        let direction = map::direction_from(&input.direction);
                        let offset = map::offset_from(&input.comb_offset_flag).unwrap_or(Offset::NONE);
                        outs.push(TdOut::Order(OrderData {
                            gateway_name: self.gw.clone(),
                            symbol: contract.symbol.clone(),
                            exchange: contract.exchange,
                            orderid,
                            order_type: OrderType::LIMIT,
                            direction: Some(direction.unwrap_or(Direction::NET)),
                            offset,
                            price: input.limit_price,
                            volume: input.volume_total_original as f64,
                            status: Status::REJECTED,
                            ..OrderData::default()
                        }));
                    }
                    outs
                }
                _ => Vec::new(),
            },
            TdEvent::RspOrderAction { error } => match error {
                Some(e) => vec![TdOut::Log(log_error_with("交易撤单失败", &self.gw, &e))],
                None => Vec::new(),
            },
            TdEvent::RtnOrder(of) => {
                if !self.contract_inited {
                    self.order_buf.push(of);
                    return Vec::new();
                }
                let contract = {
                    let m = self.contracts.lock().unwrap();
                    m.get(&of.instrument_id).cloned()
                };
                let Some(contract) = contract else {
                    // 原稿 676 直接索引(KeyError 面)→ 结构化丢弃
                    return vec![TdOut::Log(LogData {
                        gateway_name: self.gw.clone(),
                        msg: format!("委托回报缺少在册合约:{}", of.instrument_id),
                        level: LEVEL_ERROR,
                    })];
                };
                match map::order_from(&of, &contract, &self.gw) {
                    Mapped::Ok(order) => {
                        let orderid = order.orderid.clone();
                        let outs = vec![TdOut::Order(order)];
                        self.remember_sysid(&of.order_sys_id, &orderid);
                        outs
                    }
                    Mapped::Skip(reason) => vec![TdOut::Log(log_info(&self.gw, reason))],
                }
            }
            TdEvent::RtnTrade(tf) => {
                if !self.contract_inited {
                    self.trade_buf.push(tf);
                    return Vec::new();
                }
                let contract = {
                    let m = self.contracts.lock().unwrap();
                    m.get(&tf.instrument_id).cloned()
                };
                let Some(contract) = contract else {
                    return vec![TdOut::Log(LogData {
                        gateway_name: self.gw.clone(),
                        msg: format!("成交回报缺少在册合约:{}", tf.instrument_id),
                        level: LEVEL_ERROR,
                    })];
                };
                match self.sysid_orderid.get(&tf.order_sys_id) {
                    Some(orderid) => match map::trade_from(&tf, orderid, &contract, &self.gw) {
                        Mapped::Ok(trade) => vec![TdOut::Trade(trade)],
                        Mapped::Skip(reason) => vec![TdOut::Log(log_info(&self.gw, reason))],
                    },
                    None => vec![TdOut::Log(LogData {
                        gateway_name: self.gw.clone(),
                        msg: format!("成交回报缺少在册委托:{}", tf.order_sys_id),
                        level: LEVEL_ERROR,
                    })],
                }
            }
        }
    }
}

/// 发单结果(en_orderid = 成功路径;error 记拒绝 reason)。
pub struct SendOutcome {
    /// 成功时的 en_orderid(全空 = 原稿返回 `""` 的形态)
    pub en_orderid: String,
    /// 拒绝时的 log(原稿 write_log 后返回 "")
    pub error: Option<LogData>,
    /// 插单前序(发起连接/认证/登录)动作
    pub outs: Vec<TdOut>,
}

impl SendOutcome {
    fn rejected(log: LogData) -> Self {
        Self { en_orderid: String::new(), error: Some(log), outs: Vec::new() }
    }

    fn placed(outs: Vec<TdOut>, en_orderid: String) -> Self {
        Self { en_orderid, error: None, outs }
    }
}