lieui 0.1.0-alpha.1

//! 窗口层（M4）：winit 事件循环 + softbuffer 上屏。
//!
//! 这一层**只做搬运**，不含 UI 逻辑（设计 §3.8）：
//!
//! ```text
//! winit 事件 ──翻译──▶ InputEvent / Event ──▶ WindowCtx（命中 → 分发 → 状态）
//!                                             │
//! 帧循环（about_to_wait）：drain_requests → per-window tick → frame → present
//!                                             ▼
//!                       pixmap(premultiplied) ──unpremul──▶ softbuffer 0x00RRGGBB（仅脏区）
//! ```
//!
//! 三条约定：
//! 1. **逻辑 / 物理坐标**：布局与命中都吃**逻辑**像素，pixmap 与 softbuffer surface 是**物理**像素；
//!    winit 给的光标位置是物理的 ⇒ 进 `InputEvent` 前除以 `scale`。
//! 2. **局部上屏**：只把脏区那几行从 pixmap 打包进 softbuffer 缓冲，再用 `present_with_damage`
//!    提交；`age() == 0`（缓冲内容未定义）或整窗脏时退化为全量 `present()`。
//! 3. **关闭守卫**：`CloseRequested` 先问 `ViewModel::on_close_request`，`Cancel` 可拦截。
//!
//! 归 M5：IME 提交的文本 / 剪贴板（`Ctrl+C/V`）由组件（Input）消费 ——
//! 本层只负责把 `Ime::Commit` / 按键翻译成事件派发到焦点节点。

use std::collections::HashMap;
use std::num::NonZeroU32;
use std::rc::Rc;
use std::time::Instant;

use lieui_geom::{Point, Rect, Size};
use winit::application::ApplicationHandler;
use winit::event_loop::ControlFlow;
use winit::dpi::LogicalSize;
use winit::event::{ElementState, Ime, MouseButton, MouseScrollDelta, WindowEvent};
use winit::event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy};
use winit::keyboard::{Key, NamedKey};
use winit::window::{Window, WindowAttributes, WindowId as OsWindowId};

use crate::app::{App, CloseAction, ExternalData};
use crate::event::{Event, EventKind, KeyCode, Modifiers, PointerButton, PointerId};
use crate::input::InputEvent;
use crate::reactive::Dirty;
use crate::track::Kind;
use crate::window::WindowId;

// ───────────────────────── 系统剪贴板 ─────────────────────────

/// 写系统剪贴板。
///
/// 每次调用新建 `arboard::Clipboard`：Windows 上常驻句柄会在剪贴板被别的进程占用时失效，
/// 即用即开反而更稳（代价是每次一次 OpenClipboard，用户操作频率下可忽略）。
fn clipboard_set(text: &str) {
    match arboard::Clipboard::new() {
        Ok(mut cb) => {
            if let Err(e) = cb.set_text(text.to_string()) {
                eprintln!("[lieui] 写剪贴板失败：{e}");
            }
        }
        Err(e) => eprintln!("[lieui] 打开剪贴板失败：{e}"),
    }
}

fn clipboard_get() -> Option<String> {
    arboard::Clipboard::new()
        .ok()
        .and_then(|mut cb| cb.get_text().ok())
}

/// 跨线程事件（`RepaintHandle` → 事件循环）
#[derive(Debug)]
pub enum AppEvent {
    /// 唤醒事件循环跑一帧（后台线程改完状态后调用）
    Wake,
    /// 给某个窗口投递外部数据
    External {
        window: WindowId,
        data: ExternalData,
    },
}

/// 显式重绘句柄（**不是**全局单例）：后台线程用它唤醒 UI 线程。
///
/// 关键点：`Signal` 是 `!Send`，所以后台线程不能直接写 `Signal`，
/// 只能"投递数据 + 唤醒"，由 UI 线程在 `on_external` 里写。
#[derive(Clone)]
pub struct RepaintHandle {
    proxy: EventLoopProxy<AppEvent>,
}

impl RepaintHandle {
    pub fn new(proxy: EventLoopProxy<AppEvent>) -> Self {
        Self { proxy }
    }

    /// 唤醒 UI 线程（返回是否投递成功；事件循环已退出时为 `false`）
    pub fn wake(&self) -> bool {
        self.proxy.send_event(AppEvent::Wake).is_ok()
    }

    /// 投递外部数据并唤醒
    pub fn post_external(&self, window: WindowId, data: ExternalData) -> bool {
        self.proxy
            .send_event(AppEvent::External { window, data })
            .is_ok()
    }
}

impl std::fmt::Debug for RepaintHandle {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str("RepaintHandle")
    }
}

// ───────────────────────── 上屏：像素打包（纯函数，可无头测试）─────────────────────────

/// premultiplied RGBA8 → softbuffer 的 `0x00RRGGBB`（softbuffer 忽略 alpha）。
///
/// 窗口底色不透明 ⇒ 绝大多数像素走 `a == 255` 的直通路径；非不透明像素做**反预乘**，
/// 保证"半透明内容合成到不透明底"的结果正确（不会比预期更暗）。
pub fn pack_xrgb(src: &[vello_cpu::color::PremulRgba8], out: &mut [u32]) -> usize {
    let n = src.len().min(out.len());
    for i in 0..n {
        let p = src[i];
        let (r, g, b) = match p.a {
            255 => (p.r, p.g, p.b),
            0 => (0, 0, 0),
            a => {
                let un = |v: u8| {
                    let v = u32::from(v) * 255 + u32::from(a) / 2;
                    (v / u32::from(a)).min(255) as u8
                };
                (un(p.r), un(p.g), un(p.b))
            }
        };
        out[i] = (u32::from(r) << 16) | (u32::from(g) << 8) | u32::from(b);
    }
    n
}

/// 逻辑脏区 → 物理像素的 softbuffer 矩形（取整、裁剪、去重）
pub fn softbuffer_damage(
    physical: Size,
    damage: &[Rect],
    damage_all: bool,
    scale: f32,
) -> Vec<softbuffer::Rect> {
    let scaled: Vec<Rect> = damage
        .iter()
        .map(|d| {
            Rect::new(
                d.x * scale,
                d.y * scale,
                d.width * scale,
                d.height * scale,
            )
        })
        .collect();
    crate::render::damage_batches(physical, &scaled, damage_all)
        .into_iter()
        .map(|r| {
            let nz = |v: f32| {
                NonZeroU32::new((v.max(1.0).round() as u32).max(1)).unwrap_or(NonZeroU32::MIN)
            };
            softbuffer::Rect {
                x: r.x.max(0.0).round() as u32,
                y: r.y.max(0.0).round() as u32,
                width: nz(r.width),
                height: nz(r.height),
            }
        })
        .collect()
}

// ───────────────────────── 运行器 ─────────────────────────

struct WinSurface {
    window: Rc<Window>,
    surface: softbuffer::Surface<Rc<Window>, Rc<Window>>,
    /// 上一次 `surface.resize` 的物理尺寸。
    /// **初值是 `None`**：softbuffer 的 surface 建出来是 0×0，必须先 resize 才能 `buffer_mut()`
    /// （否则 win32 后端直接 panic：`Must set size of surface before calling buffer_mut()`）。
    size: Option<(u32, u32)>,
}

/// 一个 App = 一个运行器 = 事件循环内的全部窗口
struct Runner {
    app: App,
    context: Option<softbuffer::Context<Rc<Window>>>,
    windows: HashMap<WindowId, WinSurface>,
    cursor: Point,
    modifiers: winit::keyboard::ModifiersState,
    /// 打印每帧统计（`LIEUI_TRACE=1`；观测脏区效果用）
    trace: bool,
    /// 退出时置位（`App::run` 用不到返回值，这里留作观测点）
    exit_requested: bool,
}

impl Runner {
    fn new(app: App) -> Self {
        Self {
            app,
            context: None,
            windows: HashMap::new(),
            cursor: Point::zero(),
            modifiers: winit::keyboard::ModifiersState::empty(),
            trace: std::env::var_os("LIEUI_TRACE").is_some(),
            exit_requested: false,
        }
    }

    fn app_window_id(&self, os: OsWindowId) -> Option<WindowId> {
        self.windows
            .iter()
            .find(|(_, w)| w.window.id() == os)
            .map(|(id, _)| *id)
    }

    /// 为已注册的 `WindowCtx` 创建真实窗口
    fn create_window(&mut self, el: &ActiveEventLoop, id: WindowId) {
        if self.windows.contains_key(&id) {
            return;
        }
        let Some(ctx) = self.app.window_ctx(id) else {
            return;
        };
        let cfg = ctx.config().clone();

        let mut attrs = WindowAttributes::default()
            .with_title(cfg.title.clone())
            .with_inner_size(LogicalSize::new(cfg.size.width as f64, cfg.size.height as f64))
            .with_resizable(cfg.resizable)
            .with_decorations(cfg.decorations);
        if let Some(min) = cfg.min_size {
            attrs = attrs.with_min_inner_size(LogicalSize::new(min.width as f64, min.height as f64));
        }
        if let Some(max) = cfg.max_size {
            attrs = attrs.with_max_inner_size(LogicalSize::new(max.width as f64, max.height as f64));
        }

        let window = match el.create_window(attrs) {
            Ok(w) => Rc::new(w),
            Err(e) => {
                eprintln!("[lieui] 创建窗口失败：{e}");
                return;
            }
        };
        // IME：允许系统输入法（M5 的 Input 组件消费 Commit/Preedit）
        window.set_ime_allowed(true);

        let context = self.context.get_or_insert_with(|| {
            softbuffer::Context::new(Rc::clone(&window)).expect("softbuffer context")
        });
        let surface = match softbuffer::Surface::new(context, Rc::clone(&window)) {
            Ok(s) => s,
            Err(e) => {
                eprintln!("[lieui] 创建表面失败：{e}");
                return;
            }
        };

        let phys = window.inner_size();
        let scale = window.scale_factor() as f32;
        // 注意：`size` 保持 `None`（surface 还没 resize，首次 present 时再设）
        self.windows.insert(
            id,
            WinSurface {
                window,
                surface,
                size: None,
            },
        );

        // 用真实窗口尺寸/DPI 校正视图（窗口管理器可能给了别的尺寸）
        let rt = self.app.runtime();
        if let Some(ctx) = self.app.window_ctx_mut(id) {
            ctx.set_scale_factor(&rt, scale);
            let logical = Size::new(phys.width as f32 / scale, phys.height as f32 / scale);
            ctx.set_size(&rt, logical);
        }
    }

    fn destroy_window(&mut self, id: WindowId) {
        self.windows.remove(&id);
        if self.windows.is_empty() {
            // 没有窗口了：Context 依赖窗口的 display handle，一并丢弃
            self.context = None;
        }
    }

    /// 一帧：请求 → tick → frame → 上屏
    fn tick(&mut self, el: &ActiveEventLoop, now: Instant) {
        let (opened, closed) = self.app.drain_requests();
        for id in opened {
            self.create_window(el, id);
        }
        for id in closed {
            self.destroy_window(id);
        }

        let ids: Vec<WindowId> = self.app.windows().iter().map(|w| w.id()).collect();
        for id in ids {
            let rt = self.app.runtime();
            // 让 `ctx` 的借用在这一小段里结束，随后 `self.present` 才能借 `&mut self`
            let stats = {
                let Some(ctx) = self.app.window_ctx_mut(id) else {
                    continue;
                };
                // 光标闪烁：翻相位（没聚焦输入框时是 no-op）
                ctx.animate(now);
                ctx.tick(&rt, now);
                ctx.frame(&rt)
            };
            if self.trace && !stats.is_idle() {
                eprintln!(
                    "[lieui] {id:?} view={} align.patched={} layout[边界={} 移动={}] paint={}px batches={} present={}",
                    stats.view_ran,
                    stats.align.patched,
                    stats.layout.boundaries,
                    stats.layout.moved,
                    stats.rasterized_pixels(),
                    stats.render.raster.batches,
                    stats.present_pending,
                );
            }
            if stats.present_pending {
                self.present(id, &stats.damage, stats.damage_all);
            }
        }

        // 还有窗口就继续等事件（不主动 request_redraw：脏了才画）
        if self.windows.is_empty() && self.app.windows().is_empty() {
            self.exit_requested = true;
            el.exit();
            return;
        }

        // 光标闪烁调度：有聚焦输入框 ⇒ 定时唤醒；否则纯 Wait（空闲帧零功耗）
        let mut wakeup: Option<Instant> = None;
        for id in self.app.windows().iter().map(|w| w.id()) {
            if let Some(ctx) = self.app.window_ctx(id)
                && let Some(t) = ctx.next_wakeup()
            {
                wakeup = Some(match wakeup {
                    Some(prev) if prev <= t => prev,
                    _ => t,
                });
            }
        }
        el.set_control_flow(match wakeup {
            Some(t) => ControlFlow::WaitUntil(t),
            None => ControlFlow::Wait,
        });
    }

    /// 把 pixmap 的脏区打包进 softbuffer 并提交
    fn present(&mut self, id: WindowId, damage: &[Rect], damage_all: bool) {
        let Some(ctx) = self.app.window_ctx(id) else {
            return;
        };
        let physical = ctx.physical_size();
        let scale = ctx.scale_factor();
        let pixmap = ctx.pixmap();
        let pw = u32::from(pixmap.width());
        let ph = u32::from(pixmap.height());

        let Some(ws) = self.windows.get_mut(&id) else {
            return;
        };
        let (Some(nw), Some(nh)) = (NonZeroU32::new(pw), NonZeroU32::new(ph)) else {
            return;
        };

        // surface 尺寸跟随 pixmap（物理像素）；首次必须 resize（surface 初始 0×0）
        let mut resized = false;
        if ws.size != Some((pw, ph)) {
            if ws.surface.resize(nw, nh).is_ok() {
                ws.size = Some((pw, ph));
                resized = true;
            } else {
                return;
            }
        }

        ws.window.pre_present_notify();

        let mut buffer: softbuffer::Buffer<'_, Rc<Window>, Rc<Window>> =
            match ws.surface.buffer_mut() {
                Ok(b) => b,
                Err(_) => return,
            };
        let full = resized || damage_all || buffer.age() == 0;
        let batches = softbuffer_damage(physical, damage, full, scale);

        let src = pixmap.data();
        let stride = pw as usize;
        // `Buffer` 通过 `DerefMut<Target = [u32]>` 暴露像素（softbuffer 的 u32 = 0x00RRGGBB）
        {
            let dst: &mut [u32] = &mut buffer;
            if full {
                pack_xrgb(src, dst);
            } else {
                // 只打包脏区那几行（局部上屏：省掉整窗的像素拷贝）
                for r in &batches {
                    let (y, h) = (r.y as usize, r.height.get() as usize);
                    for row in y..(y + h).min(ph as usize) {
                        let start = row * stride;
                        let end = (start + stride).min(src.len()).min(dst.len());
                        if start >= end {
                            continue;
                        }
                        let s = &src[start..end];
                        let d = &mut dst[start..end];
                        let _ = pack_xrgb(s, d);
                    }
                }
            }
        }

        if full {
            let _ = buffer.present();
        } else {
            let _ = buffer.present_with_damage(&batches);
        }
    }

    // ── 事件翻译 ──

    fn to_logical(&self, id: WindowId, p: winit::dpi::PhysicalPosition<f64>) -> Point {
        let scale = self
            .app
            .window_ctx(id)
            .map(|c| c.scale_factor())
            .unwrap_or(1.0)
            .max(0.001);
        Point::new(p.x as f32 / scale, p.y as f32 / scale)
    }

    fn push_input(&mut self, id: WindowId, ev: InputEvent) {
        let rt = self.app.runtime();
        if let Some(ctx) = self.app.window_ctx_mut(id) {
            ctx.pointer(&rt, ev);
        }
    }

    fn button_of(b: MouseButton) -> PointerButton {
        match b {
            MouseButton::Left => PointerButton::Left,
            MouseButton::Right => PointerButton::Right,
            MouseButton::Middle => PointerButton::Middle,
            MouseButton::Back => PointerButton::Other(3),
            MouseButton::Forward => PointerButton::Other(4),
            MouseButton::Other(n) => PointerButton::Other(n),
        }
    }

    fn modifiers(m: winit::keyboard::ModifiersState) -> Modifiers {
        let mut out = Modifiers::EMPTY;
        if m.shift_key() {
            out |= Modifiers::SHIFT;
        }
        if m.control_key() {
            out |= Modifiers::CTRL;
        }
        if m.alt_key() {
            out |= Modifiers::ALT;
        }
        if m.super_key() {
            out |= Modifiers::META;
        }
        out
    }

    /// Ctrl+C / X / V：直接操作聚焦的输入框（剪贴板归平台层，核心不依赖 `arboard`）
    fn handle_clipboard(&mut self, id: WindowId, ev: &Event) -> bool {
        let Event::Key {
            code,
            modifiers: mods,
            ..
        } = ev
        else {
            return false;
        };
        if !mods.ctrl() {
            return false;
        }
        let KeyCode::Char(c) = code else {
            return false;
        };
        let lower = c.to_ascii_lowercase();
        if !matches!(lower, 'c' | 'x' | 'v') {
            return false;
        }

        let focus = match self.app.window_ctx(id).and_then(|w| w.track().focused) {
            Some(f) => f,
            None => return false,
        };
        // 只有文本输入框吃剪贴板（其它组件返回 false，让事件继续冒泡）
        let is_input = self
            .app
            .window_ctx(id)
            .map(|w| matches!(w.track().get(focus).map(|n| &n.kind), Some(Kind::Input { .. })))
            .unwrap_or(false);
        if !is_input {
            return false;
        }

        let copied = self
            .app
            .window_ctx(id)
            .and_then(|w| w.track().input_selected_text(focus));
        match lower {
            'c' => {
                if let Some(text) = copied {
                    clipboard_set(&text);
                }
            }
            'x' => {
                if let Some(text) = copied {
                    clipboard_set(&text);
                    if let Some(w) = self.app.window_ctx_mut(id) {
                        w.track_mut().input_backspace(focus);
                    }
                }
            }
            'v' => {
                if let Some(text) = clipboard_get()
                    && let Some(w) = self.app.window_ctx_mut(id)
                {
                    w.track_mut().input_insert(focus, &text);
                }
            }
            _ => return false,
        }
        let rt = self.app.runtime();
        rt.mark(id, Dirty::PAINT | Dirty::PRESENT);
        if let Some(ws) = self.windows.get(&id) {
            ws.window.request_redraw();
        }
        true
    }

    fn key_code(key: &Key) -> KeyCode {
        match key {
            Key::Named(n) => KeyCode::Named(match n {
                NamedKey::Enter => crate::event::NamedKey::Enter,
                NamedKey::Escape => crate::event::NamedKey::Escape,
                NamedKey::Tab => crate::event::NamedKey::Tab,
                NamedKey::Backspace => crate::event::NamedKey::Backspace,
                NamedKey::Delete => crate::event::NamedKey::Delete,
                NamedKey::Insert => crate::event::NamedKey::Insert,
                NamedKey::Space => crate::event::NamedKey::Space,
                NamedKey::ArrowLeft => crate::event::NamedKey::Left,
                NamedKey::ArrowRight => crate::event::NamedKey::Right,
                NamedKey::ArrowUp => crate::event::NamedKey::Up,
                NamedKey::ArrowDown => crate::event::NamedKey::Down,
                NamedKey::Home => crate::event::NamedKey::Home,
                NamedKey::End => crate::event::NamedKey::End,
                NamedKey::PageUp => crate::event::NamedKey::PageUp,
                NamedKey::PageDown => crate::event::NamedKey::PageDown,
                NamedKey::Shift => crate::event::NamedKey::Shift,
                NamedKey::Control => crate::event::NamedKey::Control,
                NamedKey::Alt => crate::event::NamedKey::Alt,
                NamedKey::Meta => crate::event::NamedKey::Meta,
                other => crate::event::NamedKey::Other(*other as u32),
            }),
            Key::Character(s) => s.chars().next().map(KeyCode::Char).unwrap_or(KeyCode::Named(
                crate::event::NamedKey::Other(0),
            )),
            _ => KeyCode::Named(crate::event::NamedKey::Other(0)),
        }
    }

    fn on_window_event(&mut self, _el: &ActiveEventLoop, os_id: OsWindowId, event: WindowEvent) {
        let Some(id) = self.app_window_id(os_id) else {
            return;
        };
        let rt = self.app.runtime();

        match event {
            WindowEvent::CloseRequested => {
                let action = self
                    .app
                    .window_ctx_mut(id)
                    .map(|c| c.close_requested(&rt))
                    .unwrap_or(CloseAction::Close);
                if action == CloseAction::Close {
                    self.app.close_window(id);
                    self.destroy_window(id);
                }
            }

            WindowEvent::Resized(size) => {
                let scale = self
                    .app
                    .window_ctx(id)
                    .map(|c| c.scale_factor())
                    .unwrap_or(1.0)
                    .max(0.001);
                if let Some(ctx) = self.app.window_ctx_mut(id) {
                    ctx.set_size(
                        &rt,
                        Size::new(size.width as f32 / scale, size.height as f32 / scale),
                    );
                }
            }

            WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
                if let Some(ctx) = self.app.window_ctx_mut(id) {
                    ctx.set_scale_factor(&rt, scale_factor as f32);
                }
            }

            WindowEvent::RedrawRequested => {
                let now = Instant::now();
                let stats = {
                    let Some(ctx) = self.app.window_ctx_mut(id) else {
                        return;
                    };
                    ctx.tick(&rt, now);
                    ctx.frame(&rt)
                };
                if stats.present_pending {
                    self.present(id, &stats.damage, stats.damage_all);
                }
            }

            WindowEvent::CursorMoved { position, .. } => {
                let pos = self.to_logical(id, position);
                self.cursor = pos;
                self.push_input(
                    id,
                    InputEvent::Move {
                        pointer: PointerId(0),
                        pos,
                    },
                );
            }

            WindowEvent::CursorLeft { .. } => {
                self.push_input(id, InputEvent::Leave);
            }

            WindowEvent::MouseInput { state, button, .. } => {
                let b = Self::button_of(button);
                let pos = self.cursor;
                let ev = match state {
                    ElementState::Pressed => InputEvent::Down {
                        pointer: PointerId(0),
                        pos,
                        button: b,
                    },
                    ElementState::Released => InputEvent::Up {
                        pointer: PointerId(0),
                        pos,
                        button: b,
                    },
                };
                self.push_input(id, ev);
            }

            WindowEvent::MouseWheel { delta, .. } => {
                // 符号原样透传：winit 约定正 y = 滚轮上推（各平台一致，macOS 的
                // "自然滚动"由系统换算）。消费端见 `input::default_wheel_scroll`。
                let d = match delta {
                    MouseScrollDelta::LineDelta(x, y) => (x * 48.0, y * 48.0),
                    MouseScrollDelta::PixelDelta(p) => {
                        let scale = self
                            .app
                            .window_ctx(id)
                            .map(|c| c.scale_factor())
                            .unwrap_or(1.0)
                            .max(0.001);
                        (p.x as f32 / scale, p.y as f32 / scale)
                    }
                };
                let pos = self.cursor;
                self.push_input(
                    id,
                    InputEvent::Wheel {
                        pointer: PointerId(0),
                        pos,
                        delta: d,
                    },
                );
            }

            WindowEvent::Focused(false) => {
                // 丢焦点 ⇒ 取消指针交互（必发 PointerCaptureLost，拖拽态可清理）
                self.push_input(id, InputEvent::Cancel { pointer: PointerId(0) });
            }

            WindowEvent::ModifiersChanged(m) => {
                self.modifiers = m.state();
            }

            WindowEvent::KeyboardInput { event: key, .. } => {
                let code = Self::key_code(&key.logical_key);
                let kind = match key.state {
                    ElementState::Pressed => EventKind::KeyDown,
                    ElementState::Released => EventKind::KeyUp,
                };
                let mods = Self::modifiers(self.modifiers);

                // Tab / Shift+Tab：框架默认的焦点迁移
                if key.state == ElementState::Pressed
                    && code == KeyCode::Named(crate::event::NamedKey::Tab)
                {
                    let forward = !self.modifiers.shift_key();
                    if let Some(ctx) = self.app.window_ctx_mut(id) {
                        ctx.tab(&rt, forward);
                    }
                }

                let mut ev = Event::key_with(kind, code, mods);
                if let Event::Key {
                    text, repeat: r, ..
                } = &mut ev
                {
                    *r = key.repeat;
                    if kind == EventKind::KeyDown
                        && let Key::Character(s) = &key.logical_key
                    {
                        *text = Some(s.to_string());
                    }
                }
                // 剪贴板是 OS 服务 ⇒ 平台层先处理（光标在输入框里才生效）
                if kind == EventKind::KeyDown && self.handle_clipboard(id, &ev) {
                    return;
                }
                let path = self.focus_path(id);
                self.dispatch(id, &path, &ev);
            }

            WindowEvent::Ime(ime) => match ime {
                Ime::Commit(text) => {
                    // 每个字符一条 CharacterReceived（文本输入的正确入口）
                    for ch in text.chars() {
                        let path = self.focus_path(id);
                        self.dispatch(id, &path, &Event::char_received(ch));
                    }
                }
                Ime::Preedit(text, cursor) => {
                    let path = self.focus_path(id);
                    self.dispatch(
                        id,
                        &path,
                        &Event::ImePreedit {
                            text,
                            cursor: cursor.map(|(a, b)| (a as u32, b as u32)),
                        },
                    );
                }
                Ime::Enabled | Ime::Disabled => {}
            },

            _ => {}
        }
    }

    fn focus_path(&self, id: WindowId) -> Vec<crate::track::NodeId> {
        self.app
            .window_ctx(id)
            .map(|c| match c.track().focused {
                Some(f) => crate::hit::path_to(c.track(), f),
                None => c.content_root().map(|r| vec![r]).unwrap_or_default(),
            })
            .unwrap_or_default()
    }

    fn dispatch(&mut self, id: WindowId, path: &[crate::track::NodeId], ev: &Event) {
        if path.is_empty() {
            return;
        }
        let rt = self.app.runtime();
        if let Some(ctx) = self.app.window_ctx_mut(id) {
            ctx.dispatch(&rt, path, ev);
        }
    }
}

impl ApplicationHandler<AppEvent> for Runner {
    fn resumed(&mut self, el: &ActiveEventLoop) {
        // 为所有已注册窗口建真实窗口（`App::window()` 在 run 之前注册的）
        let ids: Vec<WindowId> = self.app.windows().iter().map(|w| w.id()).collect();
        for id in ids {
            self.create_window(el, id);
        }
        self.tick(el, Instant::now());
    }

    fn user_event(&mut self, el: &ActiveEventLoop, event: AppEvent) {
        match event {
            AppEvent::Wake => {
                self.tick(el, Instant::now());
            }
            AppEvent::External { window, data } => {
                let rt = self.app.runtime();
                if let Some(ctx) = self.app.window_ctx_mut(window) {
                    ctx.external(&rt, data);
                }
                self.tick(el, Instant::now());
            }
        }
        // 唤醒后立刻重绘（避免等下一个周期）
        let dirty: Vec<WindowId> = self.app.windows().iter().map(|w| w.id()).collect();
        for id in dirty {
            let rt = self.app.runtime();
            if let Some(ctx) = self.app.window_ctx_mut(id) {
                let d = rt.peek_dirty(id);
                if d.contains(Dirty::PRESENT) || d.contains(Dirty::PAINT) || d.contains(Dirty::VIEW) {
                    if let Some(ws) = self.windows.get(&id) {
                        ws.window.request_redraw();
                    }
                    let _ = ctx;
                }
            }
        }
    }

    fn window_event(&mut self, el: &ActiveEventLoop, os_id: OsWindowId, event: WindowEvent) {
        self.on_window_event(el, os_id, event);
        // 交互产生的脏 ⇒ 请求重绘（winit 只在需要时才会给 RedrawRequested）
        if let Some(id) = self.app_window_id(os_id) {
            let rt = self.app.runtime();
            let d = rt.peek_dirty(id);
            if !d.is_empty()
                && let Some(ws) = self.windows.get(&id)
            {
                ws.window.request_redraw();
            }
        }
    }

    fn about_to_wait(&mut self, el: &ActiveEventLoop) {
        // 请求队列可能在事件里被写入（如关闭按钮 ⇒ `ctx.close_window`）
        self.tick(el, Instant::now());
    }
}

/// 进入事件循环（阻塞）。`App` 被移入运行器。
///
/// `on_ready` 在事件循环建好后、进入循环前调用 —— 这是拿到 [`RepaintHandle`]
/// 交给后台线程的唯一时机（`EventLoopProxy` 必须由 `EventLoop` 创建）。
pub fn run(
    app: App,
    on_ready: Option<Box<dyn FnOnce(RepaintHandle)>>,
) -> Result<(), Box<dyn std::error::Error>> {
    let event_loop: EventLoop<AppEvent> = EventLoop::with_user_event().build()?;
    if let Some(f) = on_ready {
        f(RepaintHandle::new(event_loop.create_proxy()));
    }
    let mut runner = Runner::new(app);
    event_loop.run_app(&mut runner)?;
    Ok(())
}

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

    fn px(r: u8, g: u8, b: u8, a: u8) -> PremulRgba8 {
        PremulRgba8::from_u8_array([r, g, b, a])
    }

    #[test]
    fn pack_xrgb_passes_through_opaque_pixels() {
        let src = [px(255, 128, 64, 255), px(0, 0, 0, 255)];
        let mut out = [0u32; 2];
        assert_eq!(pack_xrgb(&src, &mut out), 2);
        assert_eq!(out[0], 0x00FF_8040);
        assert_eq!(out[1], 0x0000_0000);
    }

    #[test]
    fn pack_xrgb_unpremultiplies_and_ignores_alpha() {
        // 半透明白：premultiplied 之后是 (128,128,128,128) ⇒ 反预乘回 (255,255,255)
        let src = [px(128, 128, 128, 128)];
        let mut out = [0u32; 1];
        pack_xrgb(&src, &mut out);
        assert_eq!(out[0], 0x00FF_FFFF);

        // alpha = 0 ⇒ 视为背景（黑），不产生除零
        let src = [px(0, 0, 0, 0)];
        pack_xrgb(&src, &mut out);
        assert_eq!(out[0], 0);
    }

    #[test]
    fn pack_xrgb_stops_at_the_shorter_side() {
        let src = [px(1, 2, 3, 255); 5];
        let mut out = [0u32; 2];
        assert_eq!(pack_xrgb(&src, &mut out), 2);
    }

    #[test]
    fn softbuffer_damage_scales_and_clamps() {
        let physical = Size::new(200.0, 100.0);
        // 逻辑 (10,10,20,20) 在 2x 下 = 物理 (20,20,40,40)
        let d = softbuffer_damage(physical, &[Rect::new(10.0, 10.0, 20.0, 20.0)], false, 2.0);
        assert_eq!(d.len(), 1);
        assert_eq!(rect_of(&d[0]), (20, 20, 40, 40));

        // 越界被裁掉
        let d = softbuffer_damage(physical, &[Rect::new(500.0, 500.0, 10.0, 10.0)], false, 1.0);
        assert!(d.is_empty());

        // 整窗脏 ⇒ 一条覆盖全窗的矩形
        let d = softbuffer_damage(physical, &[], true, 1.0);
        assert_eq!(d.len(), 1);
        assert_eq!(rect_of(&d[0]), (0, 0, 200, 100));
    }

    #[test]
    fn softbuffer_damage_uses_physical_size_at_fractional_scale() {
        let physical = Size::new(150.0, 75.0); // 逻辑 100×50 @1.5x
        let d = softbuffer_damage(physical, &[Rect::new(0.0, 0.0, 100.0, 50.0)], false, 1.5);
        assert_eq!(d.len(), 1);
        assert_eq!(rect_of(&d[0]), (0, 0, 150, 75));
    }

    fn rect_of(r: &softbuffer::Rect) -> (u32, u32, u32, u32) {
        (r.x, r.y, r.width.get(), r.height.get())
    }
}