ek_ui/

strategy_win.rs

//! 策略交易模块窗(「一模块一菜单一窗」)。
//!
//! 形制(用户裁定 2026-11-01):
//! - 主界面是**算法交易那种统一表格**:一行一个策略实例,公共列全在这里,
//!   个性化部分(参数、变量、逐合约台账)进「详情」弹窗;
//! - 添加 / 编辑 / 详情是**弹窗**,不占主窗面积;
//! - 两表:「执行中」(Idle/Inited/Running/Paused)与「已结束」(Stopped/Finished/Failed)。
//!   已结束表**只读** —— 重启走「移除后重新添加」,不让状态机出现 `Finished→Running`。
//!
//! 纪律(与 ek-ui 其它窗同):
//! - 渲染线程**不 ask**(一发问就把界面卡在插件邮箱上);
//! - 用 `push_cmd` 投命令,命令线程去问;
//! - 数据来自 `UiShared` 里的事件缓存,不在这里查引擎。

use crate::render::pinned_table_impl_cols;
use crate::state::{UiCmd, UiShared};
use ek_strategy::contract::{RowButtons, StratState, StrategyRow};

/// 窗口内两张表。
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum Tab {
    /// 执行中(Idle / Inited / Running / Paused)。
    #[default]
    Active,
    /// 已结束(Stopped / Finished / Failed),只读。
    Done,
}

impl Tab {
    /// 标签文字。
    #[must_use]
    pub fn label(self) -> &'static str {
        match self {
            Self::Active => "执行中",
            Self::Done => "已结束",
        }
    }

    /// 该状态归哪张表。
    #[must_use]
    pub fn of(state: StratState) -> Self {
        match state {
            StratState::Idle | StratState::Inited | StratState::Running | StratState::Paused => {
                Self::Active
            }
            StratState::Stopped | StratState::Finished | StratState::Failed => Self::Done,
        }
    }
}

/// 表头(顺序即列序;10 列,与总体方案 §2 L6 的 6.2 一致)。
pub const HEADERS: [&str; 10] = [
    "操作",
    "状态",
    "策略",
    "合约",
    "方向",
    "持仓",
    "目标",
    "最新价",
    "时间",
    "备注",
];

/// 「操作」列:
pub const COL_ACTIONS: usize = 0;

/// 行内动作(点击只投命令,不碰引擎)。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Act {
    /// 初始化。
    Init,
    /// 启动(暂停后是「恢复」同一条命令)。
    Start,
    /// 暂停。
    Pause,
    /// 恢复。
    Resume,
    /// 停止。
    Stop,
    /// 编辑参数(弹窗)。
    Edit,
    /// 移除(二次确认)。
    Remove,
    /// 详情(弹窗)。
    Detail,
}

/// 「添加策略」弹窗的表单态(关窗不销毁:未提交的输入留着)。
#[derive(Debug, Clone, Default)]
pub struct AddForm {
    /// 选中的策略类名(`""` = 还没选)。
    pub class_name: String,
    /// 实例名(用户填)。
    pub name: String,
    /// 参数(键 → 编码串,与 `ParamSpec` 同一口径)。
    pub params: std::collections::BTreeMap<String, String>,
    /// 本地校验/引擎回执的错误(窗内红字,不关窗)。
    pub error: Option<String>,
    /// 已提交待回执的实例名(回执 ok 即关窗)。
    pub submitted: Option<String>,
}

/// 「详情 / 编辑」弹窗的表单态。
#[derive(Debug, Clone, Default)]
pub struct DetailForm {
    /// 目标实例名。
    pub name: String,
    /// 是否处于编辑态(只读 ↔ 可改)。
    pub editing: bool,
    /// 编辑态的草稿参数。
    pub params: std::collections::BTreeMap<String, String>,
    /// 错误(窗内红字)。
    pub error: Option<String>,
    /// 已提交待回执的编辑。
    pub submitted: bool,
}

/// 策略窗的持久状态(关窗不销毁,编辑态与选中的 tab 都留在这里)。
#[derive(Debug, Default)]
pub struct StrategyWinState {
    /// 当前 tab。
    pub tab: Tab,
    /// 选中的策略名(详情/编辑弹窗的目标)。
    pub selected: Option<String>,
    /// 「添加策略」弹窗是否打开(S7 用)。
    pub add_open: bool,
    /// 添加弹窗的表单态。
    pub add_form: AddForm,
    /// 详情弹窗(打开着 = `Some`)。
    pub detail: Option<DetailForm>,
    /// 待确认移除的策略名(行内 [移除] 二次确认)。
    pub pending_remove: Option<String>,
    /// 上一次错误提示(展示在工具条下沿;用户改动作即清)。
    pub last_error: Option<String>,
    /// 排序键 `(列序, 升序)`;`None` = 按实例名的稳定序。
    ///
    /// **只作用于渲染前的副本**(W2 纪律):行表是推送来的单源事实,不在显示层就地排序。
    pub sort: Option<(usize, bool)>,
    /// 「网关设置」弹窗是否打开。
    pub engine_open: bool,
    /// 交易网关草稿(空 = 自动解析)。
    pub engine_trade: String,
    /// 行情网关草稿(空 = 不指定)。
    pub engine_md: String,
    /// 网关设置的窗内红字。
    pub engine_error: Option<String>,
    /// 已提交、等回执。
    pub engine_submitted: bool,
}

impl StrategyWinState {
    /// 新建(默认「执行中」tab)。
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// 打开详情弹窗(`editing=true` 直接进编辑态)。
    ///
    /// 参数回显**只看行表**(事件已带全量)—— 打开弹窗不发任何 ask。
    pub fn open_detail(&mut self, shared: &UiShared, name: &str, editing: bool) {
        let params = shared
            .strategy_row(name)
            .map(|r| r.params.into_iter().collect())
            .unwrap_or_default();
        self.selected = Some(name.to_string());
        self.last_error = None;
        self.detail = Some(DetailForm {
            name: name.to_string(),
            editing,
            params,
            error: None,
            submitted: false,
        });
    }

    /// 吃一条动作(下一帧生效;`repaint` 由调用方置)。
    fn on_act(&mut self, shared: &UiShared, name: &str, act: Act) {
        self.last_error = None;
        match act {
            Act::Init => shared.push_cmd(UiCmd::StratInit {
                name: name.to_string(),
            }),
            Act::Start => shared.push_cmd(UiCmd::StratStart {
                name: name.to_string(),
            }),
            Act::Pause => shared.push_cmd(UiCmd::StratPause {
                name: name.to_string(),
            }),
            Act::Resume => shared.push_cmd(UiCmd::StratResume {
                name: name.to_string(),
            }),
            Act::Stop => shared.push_cmd(UiCmd::StratStop {
                name: name.to_string(),
            }),
            Act::Edit => self.open_detail(shared, name, true),
            Act::Detail => self.open_detail(shared, name, false),
            Act::Remove => {
                // 二次确认:第一次点只是置位,再点才真的发令。
                if self.pending_remove.as_deref() == Some(name) {
                    self.pending_remove = None;
                    shared.push_cmd(UiCmd::StratRemove {
                        name: name.to_string(),
                    });
                } else {
                    self.pending_remove = Some(name.to_string());
                }
            }
        }
    }
}

/// 渲染整扇窗。返回 `true` = 需要下一帧重绘。
pub fn render(ui: &mut egui::Ui, st: &mut StrategyWinState, shared: &UiShared) -> bool {
    let mut repaint = false;

    // 失败提示:命令线程把失败也塞进回执队列(`op = "toast"`),这里取出来挂到工具条下沿。
    // 不是 toast 的就放回队首,交给弹窗自己吃(顺序不能乱)。
    loop {
        let Some(fb) = shared.take_strategy_feedback() else {
            break;
        };
        if fb.op == "toast" {
            st.last_error = Some(fb.msg);
            repaint = true;
        } else {
            shared.push_strategy_feedback_front(fb);
            break;
        }
    }

    // ---- 工具条 ----
    ui.horizontal(|ui| {
        if ui
            .selectable_label(st.tab == Tab::Active, Tab::Active.label())
            .clicked()
        {
            st.tab = Tab::Active;
            repaint = true;
        }
        if ui
            .selectable_label(st.tab == Tab::Done, Tab::Done.label())
            .clicked()
        {
            st.tab = Tab::Done;
            repaint = true;
        }
        ui.separator();
        if ui.button("添加策略…").clicked() {
            st.add_open = true;
            repaint = true;
        }
        if ui
            .button("网关…")
            .on_hover_text("默认交易/行情网关;留空 = 按合约归属或唯一已连接自动解析")
            .clicked()
        {
            st.engine_open = true;
            st.engine_error = None;
            st.engine_submitted = false;
            repaint = true;
        }
        ui.separator();
        if ui.button("全部启动").clicked() {
            shared.push_cmd(UiCmd::StratStartAll);
            repaint = true;
        }
        if ui.button("全部停止").clicked() {
            shared.push_cmd(UiCmd::StratStopAll);
            repaint = true;
        }
        if let Some(e) = &st.last_error {
            ui.separator();
            ui.colored_label(ui.visuals().error_fg_color, e);
        }
    });

    ui.add_space(6.0);

    // ---- 取行(副本;渲染层永不就地改事实源) ----
    let mut rows: Vec<StrategyRow> = shared
        .strategy_rows()
        .into_iter()
        .filter(|r| Tab::of(r.state) == st.tab)
        .collect();
    if let Some((col, asc)) = st.sort {
        sort_rows(&mut rows, col, asc);
    }

    if rows.is_empty() {
        ui.separator();
        empty_state(ui, st, shared);
        // 空表也要能弹「添加」窗(否则空态下点了钮没反应)
        if render_dialogs(ui, st, shared) {
            repaint = true;
        }
        return repaint;
    }

    // ---- 主表 ----
    let selected = st.selected.clone();
    let pending = st.pending_remove.clone();

    // 首帧同一格会跑两遍(FnMut 双 pass),动作按 (名字, 动作) 去重后再发。
    // 用 `RefCell` 而不是 `&mut Vec`:每格的闭包都要各自持有它。
    let acts: std::cell::RefCell<Vec<(String, Act)>> = std::cell::RefCell::new(Vec::new());

    let clicked = pinned_table_impl_cols(
        ui,
        "strategy_grid",
        &HEADERS,
        st.sort,
        None,
        |body, row_h| {
            for r in &rows {
                let is_sel = selected.as_deref() == Some(r.name.as_str());
                body.row(row_h, is_sel, |pr| {
                    // 0 操作
                    pr.cell(|ui, _ctx| {
                        ui.horizontal(|ui| {
                            for (label, act, enabled) in row_buttons(r) {
                                let text = if act == Act::Remove
                                    && pending.as_deref() == Some(r.name.as_str())
                                {
                                    "确认移除?"
                                } else {
                                    label
                                };
                                if ui
                                    .add_enabled(enabled, egui::Button::new(text).small())
                                    .on_hover_text(hover_of(act))
                                    .clicked()
                                {
                                    push_act(&acts, &r.name, act);
                                }
                            }
                            if ui
                                .add(egui::Button::new("详情").small())
                                .on_hover_text("看参数 / 变量 / 逐合约台账")
                                .clicked()
                            {
                                push_act(&acts, &r.name, Act::Detail);
                            }
                        });
                    });
                    // 1 状态
                    pr.cell(|ui, _ctx| {
                        ui.colored_label(state_color(ui.ctx(), r.state), r.state.label());
                    });
                    // 2 策略:实例名(行键)+ 类显示名 —— 同一个类可以有多行,只显示类名
                    // 的话两行看起来一模一样,用户分不清谁是谁。
                    pr.cell(|ui, _ctx| {
                        ui.horizontal(|ui| {
                            ui.label(egui::RichText::new(&r.name).strong());
                            let weak = crate::tokens::muted(ui.ctx());
                            ui.label(egui::RichText::new(display_of(r)).small().color(weak));
                        });
                    });
                    // 3 合约(多合约摘要)
                    pr.cell(|ui, _ctx| {
                        ui.label(symbol_summary(r));
                    });
                    // 4 方向
                    pr.cell(|ui, _ctx| match r.direction {
                        Some(ek_strategy::contract::Direction::Long) => {
                            ui.colored_label(crate::tokens::rise(ui.ctx()), "多");
                        }
                        Some(ek_strategy::contract::Direction::Short) => {
                            ui.colored_label(crate::tokens::fall(ui.ctx()), "空");
                        }
                        None => {
                            ui.weak("—");
                        }
                    });
                    // 5 持仓
                    pr.cell(|ui, _ctx| {
                        ui.label(crate::tokens::num_text(&r.pos_summary));
                    });
                    // 6 目标
                    pr.cell(|ui, _ctx| {
                        ui.label(crate::tokens::num_text(non_empty(&r.target_summary)));
                    });
                    // 7 最新价
                    pr.cell(|ui, _ctx| {
                        ui.label(crate::tokens::num_text(price_text(r.last_price)));
                    });
                    // 8 时间
                    pr.cell(|ui, _ctx| {
                        ui.label(crate::tokens::num_text(non_empty(&r.last_dt)));
                    });
                    // 9 备注
                    pr.cell(|ui, _ctx| {
                        ui.label(non_empty(&r.note));
                    });
                });
            }
        },
    );

    // 行内动作(收集完统一发,避免在格闭包里动 st)
    for (name, act) in acts.into_inner() {
        st.on_act(shared, &name, act);
        repaint = true;
    }

    // 表头点击 = 换排序(只在显示层生效;「操作」列不参与)
    if let Some(col) = clicked
        && col != COL_ACTIONS
    {
        st.sort = match st.sort {
            Some((c, asc)) if c == col => Some((col, !asc)),
            _ => Some((col, true)),
        };
        repaint = true;
    }

    if render_dialogs(ui, st, shared) {
        repaint = true;
    }

    repaint
}

// ============================ 弹窗 ============================

/// 画两个弹窗(添加 / 详情),返回是否有状态变化(要重绘)。
///
/// 纪律:这里**一次 ask 都不发**。弹窗要的一切都在 `UiShared`
/// (类元数据、行表、参数回显)或命令线程回带的回执里。
pub fn render_dialogs(ui: &mut egui::Ui, st: &mut StrategyWinState, shared: &UiShared) -> bool {
    let mut repaint = false;
    if render_add_dialog(ui, st, shared) {
        repaint = true;
    }
    if render_detail_dialog(ui, st, shared) {
        repaint = true;
    }
    if render_engine_dialog(ui, st, shared) {
        repaint = true;
    }
    repaint
}

/// 「网关设置」弹窗(方案 §5.4 的 `engine.trade_gateway` / `engine.md_gateway`)。
///
/// 为什么必须有:多账户时"取第一个"就是**赌单**。引擎的解析顺序是
/// 「显式值 → 合约归属 → 唯一已连接 → 报错」,两个都连着且合约查不到时它就红灯 ——
/// 用户得有地方把这个值填进去,而不是被逼着只能单账户。
///
/// 留空 = 交回自动解析(这是**推荐**默认:合约归属比人工填更准)。
fn render_engine_dialog(ui: &mut egui::Ui, st: &mut StrategyWinState, shared: &UiShared) -> bool {
    let mut changed = false;
    // 先吃回执(不是给这扇窗的放回去)
    if let Some(fb) = shared.take_strategy_feedback() {
        if fb.op == "engine" {
            st.engine_submitted = false;
            if fb.ok {
                st.engine_open = false;
                st.engine_error = None;
            } else {
                st.engine_error = Some(fb.msg);
            }
            changed = true;
        } else {
            shared.push_strategy_feedback_front(fb);
        }
    }
    if !st.engine_open {
        return changed;
    }

    let mut keep_open = true;
    let mut close_req = false;
    egui::Window::new("网关设置")
        .id(egui::Id::new("strategy_engine"))
        .open(&mut keep_open)
        .resizable(false)
        .default_width(420.0)
        .collapsible(false)
        .show(ui.ctx(), |ui| {
            ui.label("默认交易网关");
            if ui
                .add(
                    egui::TextEdit::singleline(&mut st.engine_trade)
                        .hint_text("留空 = 按合约归属 / 唯一已连接自动解析"),
                )
                .changed()
            {
                changed = true;
            }
            ui.add_space(4.0);
            ui.label("行情源网关");
            if ui
                .add(
                    egui::TextEdit::singleline(&mut st.engine_md)
                        .hint_text("留空 = 不指定(数据源按默认)"),
                )
                .changed()
            {
                changed = true;
            }
            ui.add_space(4.0);
            ui.label(
                egui::RichText::new(
                    "提示:多账户同时在线时,留空会让下单依赖「合约归属」;\
                     合约也查不到就会直接报错(不猜)。",
                )
                .small()
                .weak(),
            );
            if let Some(e) = &st.engine_error {
                ui.colored_label(ui.visuals().error_fg_color, e);
            }
            ui.add_space(6.0);
            ui.horizontal(|ui| {
                let can = !st.engine_submitted;
                if ui.add_enabled(can, egui::Button::new("保存")).clicked() {
                    st.engine_submitted = true;
                    st.engine_error = None;
                    shared.push_cmd(UiCmd::StratSetEngine {
                        trade_gateway: st.engine_trade.trim().to_string(),
                        md_gateway: st.engine_md.trim().to_string(),
                    });
                    changed = true;
                }
                if ui.button("取消").clicked() {
                    close_req = true;
                }
            });
        });
    if close_req || !keep_open {
        st.engine_open = false;
        st.engine_submitted = false;
        st.engine_error = None;
        changed = true;
    }
    changed
}

/// 「添加策略」弹窗。
fn render_add_dialog(ui: &mut egui::Ui, st: &mut StrategyWinState, shared: &UiShared) -> bool {
    // 类元数据:缓存是主路;空了才让命令线程去补一次(渲染线程不发 ask)。
    let metas = shared.strategy_metas();
    if st.add_open && metas.is_empty() {
        shared.push_cmd(UiCmd::StratMetaSync);
    }
    if !st.add_open {
        return false;
    }

    let mut changed = false;
    let mut open = st.add_open;

    // 先把回执吃掉(add 的回执只对"正在提交"的那一单有效)
    if let Some(fb) = shared.take_strategy_feedback() {
        if fb.op == "add" {
            if fb.ok {
                // 成功:关窗 + 清表单(行由引擎的 Upsert 事件带上来)
                st.add_open = false;
                st.add_form = AddForm::default();
                open = false;
                changed = true;
            } else if st.add_form.submitted.as_deref() == Some(fb.name.as_str()) {
                st.add_form.error = Some(fb.msg);
                st.add_form.submitted = None;
                changed = true;
            }
        } else {
            // 不是给我们这扇窗的:放回去(e.k. edit 的回执归详情窗)
            shared.push_strategy_feedback_front(fb);
        }
    }

    if !open {
        return changed;
    }

    let mut keep_open = true;
    // 窗内的「取消」不能直接动 `keep_open`(`.open()` 正借着它),先置请求位。
    let mut close_req = false;
    egui::Window::new("添加策略")
        .id(egui::Id::new("strategy_add"))
        .open(&mut keep_open)
        .resizable(true)
        .default_width(460.0)
        .collapsible(false)
        .show(ui.ctx(), |ui| {
            // ---- 类型下拉 ----
            ui.horizontal(|ui| {
                ui.label("策略类型");
                let cur = metas
                    .iter()
                    .find(|m| m.class_name == st.add_form.class_name)
                    .map_or("(请选择)", |m| m.display_name);
                egui::ComboBox::from_id_salt("strategy_add_class")
                    .selected_text(cur)
                    .show_ui(ui, |ui| {
                        for m in &metas {
                            if ui
                                .selectable_label(
                                    st.add_form.class_name == m.class_name,
                                    format!("{}（{}）", m.display_name, m.class_name),
                                )
                                .clicked()
                            {
                                // 换类型 = 表单按新类的参数集重建(不留上一类的键)
                                st.add_form.class_name = m.class_name.to_string();
                                st.add_form.params = default_params(m);
                                st.add_form.error = None;
                                changed = true;
                            }
                        }
                    });
            });
            if metas.is_empty() {
                ui.colored_label(
                    ui.visuals().warn_fg_color,
                    "还没拿到策略类(等策略插件上线后自动出现)",
                );
            }

            // ---- 实例名 ----
            ui.horizontal(|ui| {
                ui.label("实例名");
                if ui
                    .add(
                        egui::TextEdit::singleline(&mut st.add_form.name)
                            .hint_text("例如 cond_rb_1（字母开头，仅字母数字下划线）"),
                    )
                    .changed()
                {
                    changed = true;
                }
            });

            // ---- 参数区 ----
            if let Some(m) = metas
                .iter()
                .find(|m| m.class_name == st.add_form.class_name)
            {
                ui.separator();
                ui.label(egui::RichText::new("参数").strong());
                if params_form(ui, m, &mut st.add_form.params) {
                    changed = true;
                }
            }

            // ---- 错误 ----
            if let Some(e) = &st.add_form.error {
                ui.add_space(4.0);
                ui.colored_label(ui.visuals().error_fg_color, e);
            }

            ui.add_space(6.0);
            ui.horizontal(|ui| {
                let ready = !st.add_form.class_name.is_empty()
                    && !st.add_form.name.trim().is_empty()
                    && st.add_form.submitted.is_none();
                if ui.add_enabled(ready, egui::Button::new("添加")).clicked()
                    && let Some(m) = metas
                        .iter()
                        .find(|m| m.class_name == st.add_form.class_name)
                {
                    match validate_form(m, &st.add_form.params) {
                        Err(e) => {
                            st.add_form.error = Some(e);
                            changed = true;
                        }
                        Ok(params) => {
                            st.add_form.error = None;
                            let name = st.add_form.name.trim().to_string();
                            st.add_form.submitted = Some(name.clone());
                            shared.push_cmd(UiCmd::StratAdd {
                                class_name: st.add_form.class_name.clone(),
                                name,
                                params,
                            });
                            changed = true;
                        }
                    }
                }
                if ui.button("取消").clicked() {
                    close_req = true;
                    changed = true;
                }
            });
        });

    if close_req {
        keep_open = false;
    }
    if !keep_open && st.add_open {
        st.add_open = false;
        changed = true;
    }
    changed
}

/// 「详情 / 编辑」弹窗:参数 / 变量 / 逐合约三区(数据全部来自行表)。
fn render_detail_dialog(ui: &mut egui::Ui, st: &mut StrategyWinState, shared: &UiShared) -> bool {
    let Some(form) = st.detail.as_ref().map(|d| d.name.clone()) else {
        return false;
    };
    let Some(row) = shared.strategy_row(&form) else {
        // 行没了(被移除 / 引擎重启):弹窗跟着关,不留一扇挂在空气上的窗。
        st.detail = None;
        return true;
    };

    let mut changed = false;
    // 编辑回执
    if let Some(fb) = shared.take_strategy_feedback() {
        if fb.op == "edit" && fb.name == form {
            if fb.ok {
                if let Some(d) = st.detail.as_mut() {
                    d.editing = false;
                    d.submitted = false;
                    d.error = None;
                }
                changed = true;
            } else if let Some(d) = st.detail.as_mut() {
                d.error = Some(fb.msg);
                d.submitted = false;
                changed = true;
            }
        } else {
            shared.push_strategy_feedback_front(fb);
        }
    }

    let mut keep_open = true;
    let meta = shared
        .strategy_metas()
        .into_iter()
        .find(|m| m.class_name == row.class_name);

    egui::Window::new(format!("策略详情 · {}", row.name))
        .id(egui::Id::new(("strategy_detail", row.name.clone())))
        .open(&mut keep_open)
        .resizable(true)
        .default_width(520.0)
        .collapsible(false)
        .show(ui.ctx(), |ui| {
            // ---- 顶部状态条 ----
            ui.horizontal(|ui| {
                ui.colored_label(state_color(ui.ctx(), row.state), row.state.label());
                ui.separator();
                ui.label(display_of(&row));
                ui.separator();
                ui.label(non_empty(&row.note));
                ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                    if row.buttons.stop && ui.button("停止").clicked() {
                        shared.push_cmd(UiCmd::StratStop {
                            name: row.name.clone(),
                        });
                        changed = true;
                    }
                    if row.buttons.pause && ui.button("暂停").clicked() {
                        shared.push_cmd(UiCmd::StratPause {
                            name: row.name.clone(),
                        });
                        changed = true;
                    }
                });
            });
            ui.separator();

            // ---- 参数区 ----
            ui.horizontal(|ui| {
                ui.label(egui::RichText::new("参数").strong());
                if let Some(d) = st.detail.as_mut() {
                    if d.editing {
                        if ui.small_button("保存").clicked() {
                            if let Some(m) = &meta {
                                match validate_form(m, &d.params) {
                                    Err(e) => d.error = Some(e),
                                    Ok(params) => {
                                        d.error = None;
                                        d.submitted = true;
                                        shared.push_cmd(UiCmd::StratEdit {
                                            name: row.name.clone(),
                                            params,
                                        });
                                    }
                                }
                                changed = true;
                            } else {
                                d.error = Some("缺少该类参数规格,无法校验".to_string());
                                changed = true;
                            }
                        }
                        if ui.small_button("取消编辑").clicked() {
                            d.editing = false;
                            d.error = None;
                            d.params = row.params.clone().into_iter().collect();
                            changed = true;
                        }
                    } else if row.buttons.edit && ui.small_button("编辑").clicked() {
                        d.editing = true;
                        d.error = None;
                        d.params = row.params.clone().into_iter().collect();
                        changed = true;
                    }
                }
            });
            if let Some(m) = &meta {
                let d = st.detail.as_mut().expect("detail 存在");
                // 只读态:控件照画但整体禁用(读数是事实,不能就地改)。
                ui.add_enabled_ui(d.editing, |ui| {
                    if params_form(ui, m, &mut d.params) {
                        changed = true;
                    }
                });
            } else {
                // 没有规格就退化成只读键值表(不隐藏信息)
                egui::Grid::new("strategy_detail_params")
                    .num_columns(2)
                    .show(ui, |ui| {
                        for (k, v) in &row.params {
                            ui.label(k);
                            ui.label(v);
                            ui.end_row();
                        }
                    });
            }
            if let Some(e) = st.detail.as_ref().and_then(|d| d.error.clone()) {
                ui.colored_label(ui.visuals().error_fg_color, e);
            }

            // ---- 变量区 ----
            ui.separator();
            ui.label(egui::RichText::new("变量").strong());
            if row.variables.is_empty() {
                ui.weak("(策略未上报变量)");
            } else {
                egui::Grid::new("strategy_detail_vars")
                    .num_columns(2)
                    .show(ui, |ui| {
                        for (k, v) in &row.variables {
                            ui.label(k);
                            ui.label(v);
                            ui.end_row();
                        }
                    });
            }

            // ---- 逐合约区(多合约才显示)----
            if row.symbols.len() > 1 || row.positions.len() > 1 {
                ui.separator();
                ui.label(egui::RichText::new("逐合约").strong());
                egui::Grid::new("strategy_detail_pos")
                    .num_columns(3)
                    .show(ui, |ui| {
                        ui.label("合约");
                        ui.label("持仓");
                        ui.label("目标");
                        ui.end_row();
                        for (s, p, t) in &row.positions {
                            if s.starts_with('…') {
                                // 截断占位行(`…另有 N 个合约未显示`):只渲染这一句,
                                // 数值位留空 —— 别让人把 0 当成"持仓 0 手"。
                                ui.label(egui::RichText::new(s).weak());
                                ui.label("");
                                ui.label("");
                                ui.end_row();
                                continue;
                            }
                            ui.label(s);
                            ui.label(crate::tokens::num_text(p.to_string()));
                            ui.label(crate::tokens::num_text(t.to_string()));
                            ui.end_row();
                        }
                    });
            }
        });

    if !keep_open {
        st.detail = None;
        changed = true;
    }
    changed
}

/// 按 `ParamSpec` 铺一张参数表(添加 / 编辑共用同一份控件逻辑)。
///
/// 返回 `true` = 用户改过值。分节顺序吃 `ParamSpec.group`(空串归"基本")。
fn params_form(
    ui: &mut egui::Ui,
    meta: &ek_strategy::strategy::StrategyMeta,
    values: &mut std::collections::BTreeMap<String, String>,
) -> bool {
    use ek_strategy::contract::ParamKind;
    let mut changed = false;
    let mut last_group: Option<&str> = None;
    egui::Grid::new(("strategy_params", meta.class_name))
        .num_columns(2)
        .spacing([12.0, 6.0])
        .show(ui, |ui| {
            for spec in meta.params {
                let g = spec.group_or_default();
                if last_group != Some(g) {
                    ui.label(egui::RichText::new(g).strong());
                    ui.end_row();
                    last_group = Some(g);
                }
                let entry = values
                    .entry(spec.key.to_string())
                    .or_insert_with(|| spec.default.to_string());
                ui.label(spec.label);
                let r = match spec.kind {
                    ParamKind::Bool => {
                        let mut on = entry == "true";
                        let resp = ui.checkbox(&mut on, "");
                        if resp.changed() {
                            *entry = if on { "true" } else { "false" }.to_string();
                            changed = true;
                        }
                        resp
                    }
                    ParamKind::Enum { options } => {
                        let mut cur = entry.clone();
                        let resp = egui::ComboBox::from_id_salt((
                            "strategy_param_enum",
                            meta.class_name,
                            spec.key,
                        ))
                        .selected_text(cur.clone())
                        .show_ui(ui, |ui| {
                            for o in options {
                                if ui.selectable_label(cur == *o, *o).clicked() {
                                    cur = (*o).to_string();
                                }
                            }
                        })
                        .response;
                        if cur != *entry {
                            *entry = cur;
                            changed = true;
                        }
                        resp
                    }
                    ParamKind::SymbolList => {
                        let resp = ui.add(
                            egui::TextEdit::multiline(entry)
                                .desired_rows(2)
                                .hint_text("每行一个合约代码"),
                        );
                        if resp.changed() {
                            changed = true;
                        }
                        resp
                    }
                    _ => {
                        let resp = ui.add(egui::TextEdit::singleline(entry).desired_width(140.0));
                        if resp.changed() {
                            changed = true;
                        }
                        resp
                    }
                };
                if !spec.hint.is_empty() {
                    r.on_hover_text(spec.hint);
                }
                ui.end_row();
            }
        });
    changed
}

/// 一类策略的缺省参数表(键 → 编码串)。
fn default_params(
    meta: &ek_strategy::strategy::StrategyMeta,
) -> std::collections::BTreeMap<String, String> {
    meta.params
        .iter()
        .map(|s| (s.key.to_string(), s.default.to_string()))
        .collect()
}

/// 本地校验:把表单的编码串逐项过一遍 `decode_value`(服务端还会再校验一次)。
fn validate_form(
    meta: &ek_strategy::strategy::StrategyMeta,
    values: &std::collections::BTreeMap<String, String>,
) -> Result<Vec<(String, String)>, String> {
    use ek_strategy::contract::decode_value;
    let mut out = Vec::with_capacity(meta.params.len());
    for spec in meta.params {
        let raw = values
            .get(spec.key)
            .map_or(spec.default, String::as_str)
            .trim()
            .to_string();
        // 符号列表:多行 → 逗号分隔的规范串
        let raw = if matches!(spec.kind, ek_strategy::contract::ParamKind::SymbolList) {
            raw.split(['\n', ',', ' ', ';'])
                .map(str::trim)
                .filter(|s| !s.is_empty())
                .collect::<Vec<_>>()
                .join(",")
        } else {
            raw
        };
        if raw.is_empty() && !matches!(spec.kind, ek_strategy::contract::ParamKind::Str) {
            return Err(format!("「{}」不能为空", spec.label));
        }
        match decode_value(spec.kind, &raw) {
            Ok(_) => out.push((spec.key.to_string(), raw)),
            Err(e) => return Err(format!("「{}」非法:{e}", spec.label)),
        }
    }
    Ok(out)
}

/// 收一个行内动作(去重:首帧双 pass 会把同一颗点击看到两次)。
fn push_act(acts: &std::cell::RefCell<Vec<(String, Act)>>, name: &str, act: Act) {
    let mut a = acts.borrow_mut();
    if !a.iter().any(|(n, x)| n == name && *x == act) {
        a.push((name.to_string(), act));
    }
}

/// 一行的按钮组 `(文字, 动作, 可用)`。
///
/// 可用性**只读**内核投影的 [`RowButtons`] —— 界面不自己 `match` 状态。
fn row_buttons(r: &StrategyRow) -> Vec<(&'static str, Act, bool)> {
    let RowButtons {
        init,
        start,
        pause,
        stop,
        edit,
        remove,
    } = r.buttons;
    // 只读是**状态**决定的,不是"在哪个 tab":`Stopped` 身在「已结束」页,
    // 但它不是终态(Python 的 `inited` 在 stop 之后仍为 True)—— 停过的实例
    // 还能 [启动]/[编辑]。真终态(Finished/Failed)才只剩 [移除]。
    let terminal = matches!(r.state, StratState::Finished | StratState::Failed);
    let mut out = Vec::new();
    if !terminal {
        if init {
            out.push(("初始化", Act::Init, true));
        }
        if start {
            // 暂停后同一个字位换文案,动作仍是 start(resume 是 start 的语义别名)
            let label = if r.state == StratState::Paused {
                "恢复"
            } else {
                "启动"
            };
            out.push((label, Act::Start, true));
        }
        if pause {
            out.push(("暂停", Act::Pause, true));
        }
        if stop {
            out.push(("停止", Act::Stop, true));
        }
        if edit {
            out.push(("编辑", Act::Edit, true));
        }
    }
    if remove {
        out.push(("移除", Act::Remove, true));
    }
    out
}

fn hover_of(act: Act) -> &'static str {
    match act {
        Act::Init => "订阅行情、准备参数",
        Act::Start => "开始接行情与下单",
        Act::Pause => "暂停:不再收行情,持仓与参数都留着",
        Act::Resume => "继续",
        Act::Stop => "停止:先撤掉本策略全部委托",
        Act::Edit => "改参数(运行中不可改)",
        Act::Remove => "从列表里删掉(先停止)",
        Act::Detail => "看参数 / 变量 / 逐合约台账",
    }
}

/// 状态 → 颜色(只借既有语义色,不新造色板)。
fn state_color(ctx: &egui::Context, s: StratState) -> egui::Color32 {
    match s {
        StratState::Idle | StratState::Stopped => crate::tokens::muted(ctx),
        StratState::Inited => crate::tokens::info(ctx),
        StratState::Running => crate::tokens::ok(ctx),
        StratState::Paused => crate::tokens::warn(ctx),
        StratState::Finished => crate::tokens::info(ctx),
        StratState::Failed => crate::tokens::error(ctx),
    }
}

fn display_of(r: &StrategyRow) -> String {
    if r.display_name.is_empty() {
        r.class_name.clone()
    } else {
        r.display_name.clone()
    }
}

/// 合约列:`>1` 个 → `"多合约(N)"`;单个 → 代码;空 → `"—"`。
#[must_use]
pub fn symbol_summary(r: &StrategyRow) -> String {
    match r.symbols.len() {
        0 => "—".to_string(),
        1 => r.symbols[0].clone(),
        n => format!("多合约({n})"),
    }
}

fn non_empty(s: &str) -> String {
    if s.is_empty() {
        "—".to_string()
    } else {
        s.to_string()
    }
}

fn price_text(p: f64) -> String {
    if p == 0.0 {
        "—".to_string()
    } else {
        format!("{p:.2}")
    }
}

/// 按列排序(**只排副本**;`COL_ACTIONS` 不参与)。
fn sort_rows(rows: &mut [StrategyRow], col: usize, asc: bool) {
    use std::cmp::Ordering;
    let cmp = |a: &StrategyRow, b: &StrategyRow| -> Ordering {
        let o = match col {
            1 => a.state.label().cmp(b.state.label()),
            2 => display_of(a).cmp(&display_of(b)),
            3 => symbol_summary(a).cmp(&symbol_summary(b)),
            4 => format!("{:?}", a.direction).cmp(&format!("{:?}", b.direction)),
            5 => a.pos_summary.cmp(&b.pos_summary),
            6 => a.target_summary.cmp(&b.target_summary),
            7 => a
                .last_price
                .partial_cmp(&b.last_price)
                .unwrap_or(Ordering::Equal),
            8 => a.last_dt.cmp(&b.last_dt),
            9 => a.note.cmp(&b.note),
            _ => a.name.cmp(&b.name),
        };
        // 同值时按实例名兜底,保证排序稳定(每次重排不会来回跳)
        o.then_with(|| a.name.cmp(&b.name))
    };
    if asc {
        rows.sort_by(cmp);
    } else {
        rows.sort_by(|a, b| cmp(b, a));
    }
}

/// 空态引导。
fn empty_state(ui: &mut egui::Ui, st: &mut StrategyWinState, _shared: &UiShared) {
    ui.vertical_centered(|ui| {
        ui.add_space(40.0);
        ui.label(
            egui::RichText::new("尚未添加策略")
                .size(18.0)
                .color(ui.visuals().weak_text_color()),
        );
        ui.add_space(6.0);
        ui.label(
            egui::RichText::new("点上方「添加策略…」选一个模板,填参数即可开工")
                .size(13.0)
                .color(ui.visuals().weak_text_color()),
        );
        ui.add_space(18.0);
        if ui.button("添加策略…").clicked() {
            st.add_open = true;
        }
        ui.add_space(28.0);
        ui.label(
            egui::RichText::new(
                "提示:不同策略跑的是同一套东西 —— 参数不同而已。\n\
                 数据源尚未接入时,策略可以正常添加、初始化、启动、停止,只是收不到行情。",
            )
            .size(12.0)
            .color(ui.visuals().weak_text_color()),
        );
    });
}

#[cfg(test)]
mod tests {
    use super::*;

    fn row(name: &str, state: StratState, symbols: Vec<&str>) -> StrategyRow {
        StrategyRow {
            name: name.to_string(),
            state,
            symbols: symbols.into_iter().map(str::to_string).collect(),
            ..StrategyRow::default()
        }
    }

    #[test]
    fn default_tab_is_active() {
        let s = StrategyWinState::new();
        assert_eq!(s.tab, Tab::Active);
        assert!(s.selected.is_none());
        assert!(!s.add_open);
    }

    #[test]
    fn tab_labels_are_chinese() {
        assert_eq!(Tab::Active.label(), "执行中");
        assert_eq!(Tab::Done.label(), "已结束");
    }

    #[test]
    fn tabs_split_by_state() {
        for s in [
            StratState::Idle,
            StratState::Inited,
            StratState::Running,
            StratState::Paused,
        ] {
            assert_eq!(Tab::of(s), Tab::Active, "{s:?} 属于执行中");
        }
        for s in [
            StratState::Stopped,
            StratState::Finished,
            StratState::Failed,
        ] {
            assert_eq!(Tab::of(s), Tab::Done, "{s:?} 属于已结束");
        }
    }

    #[test]
    fn symbol_summary_covers_single_and_multi() {
        assert_eq!(symbol_summary(&row("a", StratState::Idle, vec![])), "—");
        assert_eq!(
            symbol_summary(&row("a", StratState::Idle, vec!["rb2611"])),
            "rb2611"
        );
        assert_eq!(
            symbol_summary(&row(
                "a",
                StratState::Idle,
                vec!["rb2611", "ag2612", "cu2612"]
            )),
            "多合约(3)"
        );
    }

    #[test]
    fn sort_keeps_source_order_untouched_and_is_stable() {
        let mut rows = vec![
            row("b", StratState::Running, vec!["rb2611"]),
            row("a", StratState::Idle, vec!["rb2611"]),
        ];
        let before = rows.iter().map(|r| r.name.clone()).collect::<Vec<_>>();
        sort_rows(&mut rows, 2, true);
        assert_eq!(rows[0].name, "a", "按策略名升序");
        // 副本排序不改源表(Rust 侧天然如此;这里钉的是调用形态:传进来的是副本)
        assert_eq!(before, vec!["b".to_string(), "a".to_string()]);
    }

    #[test]
    fn buttons_follow_state_projection() {
        let r = |state: StratState| StrategyRow {
            buttons: RowButtons::of(state, true),
            state,
            ..StrategyRow::default()
        };
        // Idle:只有初始化
        let b: Vec<_> = row_buttons(&r(StratState::Idle))
            .into_iter()
            .map(|(l, _, _)| l)
            .collect();
        assert_eq!(b, vec!["初始化", "编辑", "移除"]);
        // Running:暂停 + 停止,且**没有**编辑/移除
        let b: Vec<_> = row_buttons(&r(StratState::Running))
            .into_iter()
            .map(|(l, _, _)| l)
            .collect();
        assert_eq!(b, vec!["暂停", "停止"]);
        // Finished(已结束表):只剩移除
        let b: Vec<_> = row_buttons(&r(StratState::Finished))
            .into_iter()
            .map(|(l, _, _)| l)
            .collect();
        assert_eq!(b, vec!["移除"]);
    }

    #[test]
    fn paused_shows_resume_label() {
        let r = StrategyRow {
            buttons: RowButtons::of(StratState::Paused, true),
            state: StratState::Paused,
            ..StrategyRow::default()
        };
        let b: Vec<_> = row_buttons(&r).into_iter().map(|(l, _, _)| l).collect();
        assert!(b.contains(&"恢复"), "暂停态该显示恢复:{b:?}");
        assert!(!b.contains(&"启动"));
    }

    #[test]
    fn stopped_in_done_tab_stays_startable() {
        // 2026-11-03 裁定:只读看**状态**不看 tab。`Stopped` 在「已结束」页,
        // 但它不是终态 —— 还能启动/编辑(Python 的 inited 是粘的)。
        let r = StrategyRow {
            buttons: RowButtons::of(StratState::Stopped, true),
            state: StratState::Stopped,
            ..StrategyRow::default()
        };
        let b: Vec<_> = row_buttons(&r).into_iter().map(|(l, _, _)| l).collect();
        assert_eq!(b, vec!["启动", "编辑", "移除"], "不该再要一次初始化");
    }

    #[test]
    fn failed_is_terminal_even_outside_the_done_tab() {
        let r = StrategyRow {
            buttons: RowButtons::of(StratState::Failed, true),
            state: StratState::Failed,
            ..StrategyRow::default()
        };
        let b: Vec<_> = row_buttons(&r).into_iter().map(|(l, _, _)| l).collect();
        assert_eq!(b, vec!["移除"], "失败终态只剩移除");
    }
}