ek-ui 0.9.32

//! 运行时装配:工厂表(ui 工厂注册)、宿主观察线程(关窗→close_all)、
//! 进程主入口(eframe 主线程 + 宿主观察线程)、**启动阶段机**(0.9.5)。
//!
//! 线程形貌(S1b 双线程纪律):
//! - 主线程:eframe run_native(App 只读 [`UiShared`]);
//! - 观察线程:sleep 轮询 `UiShared::is_stop` → `engine.close_all`;
//! - 等价 headless 形貌见 ek-station bin(不带 ui 工厂)。
//!
//! 阶段机(0.9.5,用户裁定「先配置组件、运行后才出主界面;运行后装配只可看」;
//! 0.9.10 收口:装配并入「启动运行」一钮,参数面/档案包/导出清单连功能铲去):
//! - `Setup`:只画组件配置面(勾选表格 + 「启动运行」一钮),主界面不画;
//! - `Running`:主界面(`render_body`)登场;装配面转**只读**(锁旗在界面层,底层零写死);
//! - 锁只在**启动全成功**后置位(有壳没起来 = 不锁,运维面留修路);
//! - launcher 路 `auto_boot = true` = 装配+启动在开窗前走完(ready 标记协议不破)。

use std::sync::Arc;
use std::time::Duration;

use ek_core::main_engine::{MainEngine, PluginState};
use ek_core::plugin::Plugin;
use ek_dm::plugin::DmConfig;
use ek_station::{PlugKind, StationConfig, default_kinds};

use crate::plugin::{UI_NAME, UiPlugin};
use crate::state::UiShared;

/// ek-station 缺省工厂表(dm/oms/ctp;0.1.12 起 sim 已退场)+ `ui` 工厂 +
/// **rt-on 的 dm 工厂**(S4:UI 宿主观测面需要 `eBarUpdate.` 实时门;
/// ek-station headless 保持 rt-off 缺省不动 —— 两宿主的 dm 配置差异在各自
/// 工厂表,互不影响)。
///
/// `dm_rt` 是装配期参数(非配置文件;ek-ui 零配置口径,缺省 true);
/// 多次 build 同享一个 `UiShared`(ui 插件被 svctl 摘/再注,观测不丢)。
pub fn ui_kinds(shared: &Arc<UiShared>, dm_rt: bool) -> Vec<PlugKind> {
    let mut kinds: Vec<PlugKind> = default_kinds()
        .into_iter()
        .filter(|k| k.name != "dm")
        .collect();
    kinds.push(PlugKind {
        name: "dm",
        doc: "数据管理器(KlineManager;real_time 更新门开,行情板/K线页取 eBarUpdate./eBar.)",
        build: Arc::new(move || -> Arc<dyn Plugin> {
            Arc::new(ek_dm::plugin::DmPlugin::new(DmConfig {
                real_time: dm_rt,
                ..DmConfig::minute("dm")
            }))
        }),
        build_named: None,
        name_validator: None,
    });
    kinds.push(PlugKind {
        name: UI_NAME,
        doc: "常驻观测界面(eLog + eTimer 1s 快照;关窗即 stop)",
        build: {
            let shared = Arc::clone(shared);
            Arc::new(move || -> Arc<dyn Plugin> { Arc::new(UiPlugin::new(Arc::clone(&shared))) })
        },
        build_named: None,
        name_validator: None,
    });
    // 0.9.5 阶段机:天勤桥进勾选器(用户裁定并入本波)。
    // 工厂住在 ek-ui(叶仓零链):tq 不在 ek-station 缺省表,装配由勾选器发起;
    // 凭据面 = `ekapp tq-secret` 写密库 + `tq.ini` 引用行,开机 boot_with_cfg
    // 直调 apply_config 记引用 → on_start 从密库解密灌桥(tq plugin.rs spawn_engine)。
    kinds.push(PlugKind {
        name: "tq",
        doc: "天勤桥(行情/K线接入;凭据走密库引用,口令永不进档案)",
        build: Arc::new(|| -> Arc<dyn Plugin> {
            // 装配环补齐:此前这里给的是 BridgeConfig::default() —— program =
            // "python"、script = **空串**,GUI 里桥永远 spawn 不起来(python -X utf8 "")。
            // 现走 pyenv 择路(venv 优先 → EK_TQ_PYTHON → 系统 python),侧车 = 
            // 仓内 engine_real.py 绝对路径;将来打包成侧车 exe 时在 pyenv 里换择路。
            let bridge_cfg = ek_tq::bridge::BridgeConfig {
                program: ek_tq::pyenv::python_program(),
                script: ek_tq::pyenv::real_script(),
                handshake_ms: ek_tq::consts::BRIDGE_HANDSHAKE_MS,
                ..Default::default()
            };
            Arc::new(ek_tq::plugin::TqPlugin::new(
                ek_tq::plugin::TqPluginSpec::new(bridge_cfg),
            ))
        }),
        build_named: None,
        name_validator: None,
    });
    kinds
}

/// 宿主观察线程:窗口不复用的引擎在这里按 stop 位收场(close_all join)。
///
/// 纪律:close 顺序也让宿主自己走(逆 start 序),观察线程只送信号不代走步骤。
pub fn spawn_host_watcher(
    engine: &Arc<MainEngine>,
    shared: &Arc<UiShared>,
) -> std::thread::JoinHandle<()> {
    let engine = Arc::clone(engine);
    let shared = Arc::clone(shared);
    std::thread::spawn(move || {
        while !shared.is_stop() {
            std::thread::sleep(Duration::from_millis(120));
        }
        shared.log_line("[host] 窗口关闭,close_all …");
        engine.close_all(Duration::from_secs(3));
        shared.log_line("[host] 已收场");
    })
}

/// 阶段机两相(0.9.5)。
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Stage {
    /// 组件配置相(主界面未登场)。
    Setup,
    /// 运行相(主界面登场;装配面只读)。
    Running,
}

/// 启动阶段机 App(桌面 = ekapp 与 ek-ui 主程序共用的**唯一**窗口面;
/// 0.9.5 收编:原 ekapp bin 自带的 DesktopApp 副本已删,单源在此)。
pub struct StageApp {
    shared: Arc<UiShared>,
    /// 宿主引擎(0.9.2「插件即 App」:挂载表按装配名单走)。
    engine: Arc<MainEngine>,
    /// 工厂全表(勾选面的行;装配按勾选过滤)。
    kinds: Vec<PlugKind>,
    /// 勾选态(与 `kinds` 同长同序;ui 行恒真)。
    /// 0.9.10 改 `Arc<Mutex<..>>`:勾选面迁进表格层(`pinned_table`)后,格画笔是
    /// 延迟执行的 FnMut 闭包(收集期不能各借用 `&mut self.sel` 两次)→ 走**内部
    /// 可变**共享句柄,每格 clone 一个 `Arc`(与账户表的 `UiShared` 同一手法)。
    sel: Arc<std::sync::Mutex<Vec<bool>>>,
    /// 档案托底根(装配时 `boot_with_cfg` 直调;None = 退回纯装配)。
    store: Option<ek_cfg::Store>,
    /// 当前相。
    stage: Stage,
    /// 配置面回执(装配/启动显形)。
    notice: Option<String>,
    /// launcher 协议 ready 标记(启动成功后写;无 = 不写)。
    ready_marker: Option<std::path::PathBuf>,
    /// 观察线程句柄(开窗即挂;关窗收场同一条路)。
    watcher: Option<std::thread::JoinHandle<()>>,
}

impl StageApp {
    /// 配置相起步(桌面 ekapp 用:开窗时引擎**未装配未启动**)。
    #[must_use]
    pub fn new_setup(
        engine: Arc<MainEngine>,
        shared: Arc<UiShared>,
        kinds: Vec<PlugKind>,
        store: Option<ek_cfg::Store>,
        ready_marker: Option<std::path::PathBuf>,
    ) -> Self {
        let sel = kinds.iter().map(|_| true).collect::<Vec<bool>>();
        Self {
            shared,
            engine,
            kinds,
            sel: Arc::new(std::sync::Mutex::new(sel)),
            store,
            stage: Stage::Setup,
            notice: None,
            ready_marker,
            watcher: None,
        }
    }

    /// 当前相(判据面读路)。
    #[must_use]
    pub fn stage(&self) -> Stage {
        self.stage
    }

    /// 勾选项(工厂名表;ui 行恒真)。
    #[must_use]
    pub fn picked(&self) -> Vec<String> {
        self.kinds
            .iter()
            .zip(self.sel.lock().unwrap().iter())
            .filter(|(_, ok)| **ok)
            .map(|(k, _)| k.name.to_string())
            .collect()
    }

    /// 装配相 = 引擎里已有壳(装配已发生)。
    #[must_use]
    pub fn assembled(&self) -> bool {
        !self.engine.plugin_names().is_empty()
    }

    /// 勾选开关(判据面与后续持久化用)。
    ///
    /// ui 行恒勾**短路**(S4b 纪律,0.9.10 修隐藏 bug:旧写法 `on && name != UI_NAME`
    /// 对 ui 行的任何调用都写 false = 数据口能把主界面勾掉,渲染口灰显管不住它)。
    pub fn set_selected(&mut self, name: &str, on: bool) {
        if name == UI_NAME {
            return; // ui 行恒真,任何写入都短路(与渲染面灰显同一条纪律)。
        }
        if let Some(i) = self.kinds.iter().position(|k| k.name == name) {
            self.sel.lock().unwrap()[i] = on;
        }
    }

    /// 「装配」(0.9.10 并入「启动运行」一钮,界面**无独立装配钮**;`do_start`
    /// 未装配时自动先走这一步)。
    ///
    /// pub 只给判据面分步验状态机(装配态/失败态单独钉)。
    ///
    /// 失败 = 显形回执,**不锁、不起跑**(用户 0.9.10 裁定:「装配失败就正常提示
    /// 报错,然后等待用户」—— 留在配置相,勾可改、钮可再点)。
    pub fn do_assemble(&mut self) -> String {
        let mut kinds: Vec<PlugKind> = self
            .kinds
            .iter()
            .enumerate()
            .filter(|(i, _)| self.sel.lock().unwrap()[*i])
            .map(|(_, k)| k.clone())
            .collect();
        // 升级方案步骤 1(用户裁定):cfg = 核心插件,**启用清单必含,装配必含,
        // 系统注入不吃勾选**(勾选面剔除 cfg 行,用户无需也无处取消它)。
        if !kinds.iter().any(|k| k.name == "cfg")
            && let Some(k) = self.kinds.iter().find(|k| k.name == "cfg")
        {
            kinds.push(k.clone());
        }
        let names: Vec<String> = kinds.iter().map(|k| k.name.to_string()).collect();
        let cfg = StationConfig {
            plugins: names.clone(),
        };
        let r = match &self.store {
            Some(s) => ek_station::boot_with_cfg(&self.engine, &kinds, &cfg, Some(s)),
            None => ek_station::boot(&self.engine, &kinds, &cfg),
        };
        match r {
            Ok(_) => {
                self.shared
                    .log_line(format!("[ui] 装配:{} 壳(未启动)", names.join(",")));
                format!("已装配 {} 壳:{}", names.len(), names.join(","))
            }
            Err(e) => {
                let msg = format!("装配失败:{e:?}");
                self.shared.log_line(format!("[ui] {msg}"));
                msg
            }
        }
    }

    /// 「启动运行」(0.9.10 一钮两义,用户裁定「启动的时候自然要先装配再运行」):
    /// 未装配 → 先按勾选装配,装配成功才起跑;**装配失败 = 提示报错、留在配置相
    /// 等用户**(不起跑、不锁,勾可改钮可再点 —— 0.9.10 裁定)。
    ///
    /// 已装配(装配失败后重试等)→ 直接起跑。`engine.start()` + ready 标记 +
    /// 账户清点;**全壳 Running 才置装配锁**(有壳没起来 = 不锁,运维面留修路)。
    pub fn do_start(&mut self) -> String {
        if !self.assembled() {
            let msg = self.do_assemble();
            if !self.assembled() {
                // 装配失败:回执显形,等待用户(0.9.10)。
                return msg;
            }
            let _ = msg;
        }
        if let Err(e) = self.engine.start() {
            // start 整段失败:主界面照常出(半运行态),不锁,显形留修路。
            self.stage = Stage::Running;
            self.shared.set_assembly_locked(false);
            self.ensure_watcher();
            let msg = format!("启动失败:{e:}(运维面可修,装配不锁定)");
            self.shared.log_line(format!("[ui] {msg}"));
            return msg;
        }
        let not_ready: Vec<String> = self
            .engine
            .plugin_names()
            .into_iter()
            .filter(|n| !matches!(self.engine.get_state(n), Some(PluginState::Running)))
            .collect();
        self.stage = Stage::Running;
        self.shared.set_assembly_locked(not_ready.is_empty());
        self.ensure_watcher();
        self.write_ready_marker();
        // 账户清点(手点连接裁定:桌面 = 清点列回,手点才连;起连在运行相)。
        // 0.9.10 用户实锤「勾了自动连接,登录时为什么没连还要人工点?」:勾选此前
        // **只喂守护路**(`--from` 起连),桌面相清单一律列回不连 = 勾选在桌面形同虚设。
        // 修复:清点列回后,**勾选项自动入列 Connect**(与面板手点同一出令处 push_connect)。
        let shared_restore = Arc::clone(&self.shared);
        std::thread::spawn(move || {
            let rows = shared_restore.restore_saved_accounts();
            for gw in &rows {
                let Some(a) = shared_restore.account(gw) else {
                    continue;
                };
                if a.auto_connect
                    && matches!(a.stage, crate::state::AccountStage::NotAssembled)
                    && !a.connected
                {
                    let form = a.form.clone();
                    crate::render::push_connect(&shared_restore, gw, &form);
                }
            }
        });
        let msg = if not_ready.is_empty() {
            "已启动:装配面已锁定(只可看不可动)".to_string()
        } else {
            format!(
                "已启动,{} 壳未就绪:{} — 装配**不锁定**(运维面留修路)",
                not_ready.len(),
                not_ready.join(",")
            )
        };
        self.shared.log_line(format!("[ui] {msg}"));
        msg
    }

    fn ensure_watcher(&mut self) {
        if self.watcher.is_none() {
            self.watcher = Some(spawn_host_watcher(&self.engine, &self.shared));
        }
    }

    fn write_ready_marker(&self) {
        let Some(marker) = &self.ready_marker else {
            return;
        };
        use std::io::Write;
        if let Ok(mut f) = std::fs::File::create(marker) {
            let _ = f.write_all(crate::launch::READY_TEXT.as_bytes());
        }
    }

    /// 组件配置面板(Setup 相中央面板;判据 U-S1a 的查控件面在此,判据面可见)。
    ///
    /// 0.9.10 收口(用户两条裁定):
    /// - **表格 = 主界面同一张表格**:`pinned_table`(表格层)—— 列宽首帧按内容
    ///   量(装载/组件列收小、说明列吃剩余),表头带/行线/悬停整行跳色全部同源,
    ///   不再手搭 Grid(Grid 均分列宽 = 用户报的「内容很短列很宽」病根)。
    /// - **按钮只剩一个「启动运行」**:装配并入(点钮 = 按勾选装配 → 起跑;装配
    ///   失败 = 提示报错留在本相等用户)。参数面/档案包/导出启动清单三钮**连功能
    ///   一起铲**(0.9.10 裁定「功能代码要连根铲」;守护路 `--pick`/`--from` 不受影响)。
    pub fn render_setup_panel(&mut self, ui: &mut egui::Ui) {
        use crate::render::{OpTone, op_button, pinned_table};
        ui.heading("组件配置(启动前)");
        ui.label("勾选要装载的组件 → 「启动运行」(先按勾选装配,再起跑;装配失败会报错,等您改勾选后重按)。");
        ui.separator();
        let sel = Arc::clone(&self.sel);
        // **定量高度子区**(0.9.10 实锤修复,用户报「启动的按钮到哪去了」):
        // `pinned_table` = egui_table 的 ScrollArea **吃光 CentralPanel 剩余高度**,
        // 表格后面的「已选/启动运行」区被顶出可视区 = 按钮画得出、看不见。
        // 口径 = 按行数定量(表头带 + n 行 + 余量),宽度照吃父宽(列宽内容量测
        // 与补宽逻辑在子区内照常成立;主界面大表不约束,照旧吃满)。
        let (row_h, head_h) = crate::render::table_heights(ui);
        let table_h = head_h + ui.visuals().clip_rect_margin
            + self.kinds.len() as f32 * row_h
            + 6.0;
        let avail_x = ui.available_width();
        ui.allocate_ui(egui::vec2(avail_x, table_h), |ui| {
            pinned_table(ui, "setup_grid", &["装载", "组件", "说明"], |body, row_h| {
                for (i, k) in self.kinds.iter().enumerate() {
                    let name = k.name.to_string();
                    let doc = k.doc.to_string();
                    let sel_cell = Arc::clone(&sel);
                    let label0 = name.clone();
                    body.row(row_h, false, |row| {
                        row.cell(move |ui, _ctx| {
                            if label0 == UI_NAME {
                                // S4b:ui 行恒勾灰显(勾掉 = 主界面自灭,逻辑不许成立)。
                                let mut t = true;
                                ui.add_enabled(false, egui::Checkbox::new(&mut t, ""));
                                sel_cell.lock().unwrap()[i] = true;
                            } else {
                                let mut on = sel_cell.lock().unwrap()[i];
                                if ui.checkbox(&mut on, "").changed() {
                                    sel_cell.lock().unwrap()[i] = on;
                                }
                            }
                        });
                        let label = name.clone();
                        row.cell(move |ui, _ctx| {
                            ui.label(egui::RichText::new(&label).strong());
                        });
                        row.cell(move |ui, _ctx| {
                            ui.add(
                                egui::Label::new(egui::RichText::new(&doc))
                                    .wrap_mode(egui::TextWrapMode::Extend),
                            );
                        });
                    });
                }
            });
        });
        ui.separator();
        let picked = self.picked();
        ui.label(if picked.is_empty() {
            "已选: (无)".to_string()
        } else {
            format!("已选: {}", picked.join(", "))
        });
        ui.horizontal(|ui| {
            if ui
                .add_enabled_ui(!picked.is_empty(), |ui| {
                    op_button(ui, "启动运行", OpTone::Primary).clicked()
                })
                .inner
            {
                self.notice = Some(self.do_start());
            }
        });
        if let Some(n) = &self.notice {
            ui.label(egui::RichText::new(n.as_str()).monospace().small());
        }
    }
}

impl eframe::App for StageApp {
    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
        // **两相同一套样式**(0.9.10 实锤根因,用户报「Setup 表头和内容的颜色字号
        // 跟主界面根本不一样」):主界面 `render_body` 每帧头一件事就是
        // `apply_ui_style`(tokens 字号阶梯 + theme + 整套 visuals),而 Setup 相
        // 过去直接画面板 = 三件事一件没跑 = egui 默认 style(字号阶梯偏小)+
        // eframe 默认 Visuals(≠ tokens 全套)= 表头带底/行线/字号全两样。
        // 提到 update 头 = Setup 相吃同一套;render_body 内部同调用幂等,不重复计费。
        crate::render::apply_ui_style(ctx, self.shared.theme());
        // 0.9.10:参数面窗组与档案包窗**连功能铲去**(用户裁定「后面几个按钮都可以
        // 不要……功能代码要连根铲」)。中央面板是唯一窗口面;守护路 `--pick`/`--from`
        // 不经这里,不受影响。
        // 中央面板唯一形貌:配置相 = 组件配置面;运行相 = 主界面
        // (官方纪律:CentralPanel 最后,BD-UI-29;两相各只画一个 CentralPanel)。
        if self.stage == Stage::Setup {
            self.setup_fit_once(ctx);
            egui::CentralPanel::default().show(ctx, |ui| {
                self.render_setup_panel(ui);
            });
        } else {
            // **相变一次复位**(0.9.10,与一次性适应同一族纪律):Setup 相把窗收到
            // 配置面内容宽后,主界面(1280×860 大屏)吃不下小窗 = 转 Running 的
            // 那一拍发**一次** InnerSize 复位到主界面几何;此后照用户裁定不再自动
            // 调(最大化/拖拽 = 用户接管 = 不发)。
            let sent_key = egui::Id::new("running_geo_sent");
            if !ctx.data(|d| d.get_temp::<bool>(sent_key).unwrap_or(false)) {
                ctx.data_mut(|d| d.insert_temp(sent_key, true));
                let maximized = ctx.viewport(|vp| vp.builder.maximized.unwrap_or(false));
                if !maximized {
                    ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(egui::vec2(
                        1280.0, 860.0,
                    )));
                }
            }
            crate::render_body(ctx, &self.shared);
        }
        ctx.request_repaint_after(Duration::from_secs(1));
    }
}

impl StageApp {
    /// 主窗 Setup 相**一次性适应**(0.9.10 用户裁定「表格第一次填充之后调一次,
    /// 后面就不用管它」+「所有弹窗同规」—— 主窗配置面也照此规):
    /// 隐形量尺(probe)跑配置面内容 → 自然尺寸连续 3 帧稳定且已过 6 帧 →
    /// 发一次 InnerSize(夹 [420,260]..[1280,900])→ done → 本窗 fit 退役。
    /// 最大化帧 = 用户接管 = 不量不发(与独立窗 FitOneShot 同一套纪律,同病根:
    /// 旧 1280 缺省宽 vs 配置面窄内容 = 用户报「内容没多少、表特别大」)。
    fn setup_fit_once(&mut self, ctx: &egui::Context) {
        use egui::Id;
        #[derive(Clone, Copy)]
        struct FitOneShot {
            w: f32,
            h: f32,
            stable: u8,
            frames: u16,
            done: bool,
        }
        let key = Id::new(("fit_oneshot", "ekapp_main"));
        let st = ctx.data(|d| d.get_temp::<FitOneShot>(key)).unwrap_or(FitOneShot {
            w: -1.0,
            h: -1.0,
            stable: 0,
            frames: 0,
            done: false,
        });
        let maximized = ctx.viewport(|vp| vp.builder.maximized.unwrap_or(false));
        if st.done || maximized {
            return;
        }
        let mut sc = (*ctx.style()).clone();
        sc.wrap_mode = Some(egui::TextWrapMode::Extend);
        let measure_w = ctx
            .data(|d| d.get_temp::<f32>(Id::new(("fit_w", "ekapp_main"))).unwrap_or(48.0));
        let mut probe = egui::Ui::new(
            ctx.clone(),
            Id::new(("fit_probe", "ekapp_main")),
            egui::UiBuilder::new()
                .global_scope(true)
                .invisible()
                .style(sc)
                .max_rect(egui::Rect::from_min_size(
                    egui::pos2(0.0, 0.0),
                    egui::vec2(measure_w.max(48.0), 1.0e5),
                ))
                .layout(egui::Layout::top_down(egui::Align::Min)),
        );
        self.render_setup_panel(&mut probe);
        let nat_w = probe.min_rect().width();
        let nat_h = probe.min_rect().height();
        ctx.data_mut(|d| d.insert_temp(Id::new(("fit_w", "ekapp_main")), nat_w));
        let stable = (nat_w - st.w).abs() < 0.5 && (nat_h - st.h).abs() < 0.5;
        let mut next = FitOneShot {
            w: nat_w,
            h: nat_h,
            stable: if stable { st.stable + 1 } else { 0 },
            frames: st.frames + 1,
            done: false,
        };
        if next.stable >= 3 && next.frames >= 6 {
            let want = egui::vec2(
                (nat_w + 20.0).clamp(420.0, 1280.0),
                (nat_h + 26.0).clamp(260.0, 900.0),
            );
            ctx.send_viewport_cmd(egui::ViewportCommand::InnerSize(want));
            next.done = true;
        }
        ctx.data_mut(|d| d.insert_temp(key, next));
    }
}

/// 运行选项(S1c ready 标记 + S4 dm real_time 装配参数;ek-ui 零配置口径,
/// 无任何配置文件输入 —— 结构只由 StationConfig 清单决定)。
#[derive(Debug, Clone)]
pub struct RunOpts {
    /// launcher 协议:`start 成功后写 "ready\n"` 的标记路径。
    pub ready_marker: Option<std::path::PathBuf>,
    /// dm 工厂 real_time 门(装配参数,缺省 true —— UI 宿主观测面要实时门)。
    pub dm_rt: bool,
    /// 0.9.5 阶段机:true = 开窗前装配+启动走完(launcher/headless 式一次性启动,
    /// ready 协议不破);false = 从配置相起步(桌面 ekapp 裁定面)。
    pub auto_boot: bool,
}

impl Default for RunOpts {
    /// 缺省:无 ready 标记 + **dm_rt = true**(UI 宿主缺省实时门;
    /// 勿改回 derive(Default) —— bool 缺省 false 会静默关实时门)
    /// + **auto_boot = true**(launcher/主程序旧口径:开窗即运行相)。
    fn default() -> Self {
        Self {
            ready_marker: None,
            dm_rt: true,
            auto_boot: true,
        }
    }
}

impl RunOpts {
    /// 空选项(无 ready 标记)。
    pub fn plain() -> Self {
        Self::default()
    }
}

/// 进程主入口:装配(dm/oms/ctp/ui 按清单)→ start → 就绪标记(可选)
/// → eframe 主循环 → 观察线程收场。
pub fn run_station_ui(cfg: &StationConfig, opts: &RunOpts) -> Result<(), String> {
    let engine = Arc::new(MainEngine::new(None));
    let shared = Arc::new(UiShared::new());
    let store = ek_cfg::Store::eco();

    // 配置托底根(0.6.0/BD-CFG 环节8):UI 宿主与 headless 同口径 ——
    // `Store::eco()` 成功 → `boot_with_cfg`(开机逐插件 apply_persisted,
    // 受理三行序在插件 worker 面);eco 失败(平台缺配置目录,罕见)→
    // 退回 `boot()`(cfg 收件壳仍在场,fallback 直写仍通,UI 行为即旧版零变)。
    let store_ok = store.ok();
    if opts.auto_boot {
        let boot = match &store_ok {
            Some(s) => {
                ek_station::boot_with_cfg(&engine, &ui_kinds(&shared, opts.dm_rt), cfg, Some(s))
            }
            None => ek_station::boot(&engine, &ui_kinds(&shared, opts.dm_rt), cfg),
        };
        boot.map_err(|e| format!("boot: {e:?}"))?;
        // start 失败也要走 close_all(0.4.3 BD-UI-64,审核 P3;与 ek-station headless
        // main.rs 的 start 失败路径同口径):start 是逐个 launch 的,失败时已有插件在
        // Running —— 不闭就没有 on_stop(网关侧的会话收尾与流目录处理被跳过)。
        // boot 失败不用闭:那时插件只登记未 launch,没有 worker 要收。
        if let Err(e) = engine.start() {
            engine.close_all(Duration::from_secs(3));
            return Err(format!("start: {e:?}"));
        }
        shared.set_assembly_locked(true);
    }

    let mut app = StageApp::new_setup(
        Arc::clone(&engine),
        Arc::clone(&shared),
        ui_kinds(&shared, opts.dm_rt),
        store_ok,
        opts.ready_marker.clone(),
    );
    if opts.auto_boot {
        app = StageApp {
            stage: Stage::Running,
            ..app
        };
        app.write_ready_marker();
    }

    let watcher = spawn_host_watcher(&engine, &shared);
    // 观察线程句柄交 App 之外统一 join(与 0.9.4 同路;App 内 ensure_watcher 幂等)。
    let _ = &watcher;

    let opts = eframe::NativeOptions {
        viewport: egui::ViewportBuilder::default()
            .with_inner_size([1280.0, 860.0])
            .with_title("ek-station"),
        ..Default::default()
    };
    // 关窗即收:run_native 返回 = 窗口已关 → 置 stop → 观察线程 close_all(BD-UI-11)。
    let result = eframe::run_native(
        "ek-station",
        opts,
        Box::new(|cc| {
            crate::fonts::apply_cjk_fonts(&cc.egui_ctx); // BD-UI-26:CJK 回退,中文不乱码
            Ok(Box::new(app) as Box<dyn eframe::App>)
        }),
    );
    shared.request_stop();
    let _ = watcher.join();
    result.map_err(|e| format!("ui: {e:?}"))
}

/// 桌面产品入口(ekapp 无参数路,0.9.5 起单源在此):**从配置相起步** ——
/// 开窗不装配不启动(用户裁定「先配置组件、运行后才出主界面」);
/// 观察线程在开窗即挂(Setup 关窗也走 close_all 收尾,U-S3b 口径)。
pub fn run_desktop() -> Result<(), String> {
    let engine = Arc::new(MainEngine::new(None));
    let shared = Arc::new(UiShared::new());
    let store = ek_cfg::Store::eco().ok();
    let app = StageApp::new_setup(
        Arc::clone(&engine),
        Arc::clone(&shared),
        ui_kinds(&shared, true),
        store,
        None,
    );
    let watcher = spawn_host_watcher(&engine, &shared);
    let opts = eframe::NativeOptions {
        viewport: egui::ViewportBuilder::default()
            .with_inner_size([1280.0, 860.0])
            .with_title("ek-station 桌面"),
        ..Default::default()
    };
    let result = eframe::run_native(
        "ek-station 桌面",
        opts,
        Box::new(|cc| {
            crate::fonts::apply_cjk_fonts(&cc.egui_ctx);
            Ok(Box::new(app) as Box<dyn eframe::App>)
        }),
    );
    shared.request_stop();
    let _ = watcher.join();
    result.map_err(|e| format!("ui: {e:?}"))
}