atmos/kernel/

window_mgr.rs

//! 多層ウィンドウマネージャ。
//!
//! [`App`] トレイトを実装する各アプリ（[`crate::apps`]）をウィンドウとして重ね合わせ表示・
//! 入力ルーティングする。スタートボタン・タスクバーは持たず、ウィンドウは重ね合わせ型
//! （`spec/README.md`「UI 方針」）。`ProxyApp` はバックグラウンドスレッドで動くアプリ
//! （別コアで動く `app_runner_entry`）をメインループ側の `App` として橋渡しする。
// src/window_mgr.rs - Multi-layered Window Manager for AtmOS
#![allow(dead_code)]

extern crate alloc;
use alloc::boxed::Box;
use alloc::string::String;
use alloc::vec::Vec;

use crate::kernel::draw::{Color, Screen};

/// アプリケーションが実装すべきトレイト
pub trait App {
    fn name(&self) -> &str;

    /// ProxyApp であるかどうか
    fn is_proxy(&self) -> bool {
        false
    }

    /// 共有されるバックバッファを返す
    fn get_shared_buffer(&self) -> Option<alloc::sync::Arc<spin::Mutex<alloc::vec::Vec<u32>>>> {
        None
    }

    /// インスタンス特有の情報（ファイル名やURLなど）を返す
    fn instance_info(&self) -> alloc::string::String {
        alloc::string::String::new()
    }

    /// ウィンドウ内の描画要求
    fn draw(&mut self, screen: &Screen, win_x: u32, win_y: u32, win_w: u32, win_h: u32);

    /// マウスイベント。ローカル座標とホイール移動量が渡される。
    fn on_mouse(&mut self, local_x: i32, local_y: i32, btn_left: bool, btn_right: bool, wheel: i32);

    /// キーボードイベント
    fn on_key(&mut self, keycode: u8, pressed: bool, ascii: Option<char>);

    // -----------------------------------------------------------------------
    // OS一元管理型 縦タブ API (デフォルト実装付き)
    // -----------------------------------------------------------------------

    /// タブタイトル一覧。空を返すとタブなし扱い（非推奨: 全アプリは最低1タブ持つ）
    fn tabs(&self) -> alloc::vec::Vec<alloc::string::String> {
        alloc::vec![alloc::string::String::from(self.name())]
    }
    fn active_tab(&self) -> usize {
        0
    }
    fn switch_tab(&mut self, _idx: usize) {}
    fn add_tab(&mut self) {}
    /// タブを閉じる。最後のタブが閉じられウィンドウも閉じる場合は true を返す。
    fn close_tab(&mut self, _idx: usize) -> bool {
        true
    }

    /// Alt+O: ファイルオープンダイアログを開く（未実装アプリはno-op）
    fn open_file_dialog(&mut self) {}
    /// Alt+S: ファイルを保存する（未実装アプリはno-op）
    fn save_file(&mut self) {}

    /// このアプリの各タブ用バックグラウンドスレッド関数を返す。
    /// Some(fn) を返したアプリはタブ追加時にスケジューラでスレッドを起動する。
    /// スレッド関数は引数なしの fn() で、グローバル Mutex 経由でアプリ状態と通信する。
    fn tab_thread_fn(&self) -> Option<fn()> {
        None
    }

    // DOM値操作用API (デフォルト実装付き)
    fn get_dom_value(&self, _id: &str) -> Option<alloc::string::String> {
        None
    }
    fn set_dom_value(&mut self, _id: &str, _val: &str) {}

    // タイマーベースの再描画要求（ローディングアニメーション用など）
    fn needs_timer_redraw(&self) -> bool {
        false
    }

    /// ProxyApp の shared_buffer が更新されたことを通知する AtomicBool を返す。
    /// ProxyApp でない通常のアプリは None を返す（デフォルト実装）。
    /// Core 0 の dirty 判定がこのフラグを読んで矩形を登録する。
    fn get_buffer_updated_flag(&self) -> Option<alloc::sync::Arc<core::sync::atomic::AtomicBool>> {
        None
    }

    // DOMコンテンツ操作用API (デフォルト実装付き)
    fn get_dom_content(&self, _id: &str) -> Option<alloc::string::String> {
        None
    }
    fn set_dom_content(&mut self, _id: &str, _val: &str) {}

    /// ウィンドウサイズ変更の通知
    fn on_resize(&mut self, _width: u32, _height: u32) {}
}

use alloc::sync::Arc;
use spin::Mutex;
use core::sync::atomic::AtomicBool;

#[derive(Clone, Debug)]
pub enum AppEvent {
    Mouse {
        local_x: i32,
        local_y: i32,
        btn_left: bool,
        btn_right: bool,
        wheel: i32,
    },
    Key {
        keycode: u8,
        pressed: bool,
        ascii: Option<char>,
    },
    SwitchTab(usize),
    AddTab,
    CloseTab(usize),
    Resize {
        width: u32,
        height: u32,
    },
}

pub struct ProxyApp {
    pub name: String,
    pub shared_buffer: Arc<Mutex<Vec<u32>>>,
    pub event_queue: Arc<Mutex<Vec<AppEvent>>>,
    pub is_alive: Arc<AtomicBool>,
    pub active_tab: Arc<Mutex<usize>>,
    pub tabs: Arc<Mutex<Vec<String>>>,
    pub needs_timer_redraw: Arc<AtomicBool>,
    /// app_runner_entry 側が shared_buffer を更新したらセットされるフラグ。
    /// Core 0 の dirty 判定がこれを読んでウィンドウ矩形を dirty 登録し、クリアする。
    pub buffer_updated: Arc<AtomicBool>,
}

impl ProxyApp {
    pub fn new(
        name: &str,
        shared_buffer: Arc<Mutex<Vec<u32>>>,
        event_queue: Arc<Mutex<Vec<AppEvent>>>,
        is_alive: Arc<AtomicBool>,
        active_tab: Arc<Mutex<usize>>,
        tabs: Arc<Mutex<Vec<String>>>,
        needs_timer_redraw: Arc<AtomicBool>,
        buffer_updated: Arc<AtomicBool>,
    ) -> Self {
        Self {
            name: String::from(name),
            shared_buffer,
            event_queue,
            is_alive,
            active_tab,
            tabs,
            needs_timer_redraw,
            buffer_updated,
        }
    }
}

impl App for ProxyApp {
    fn name(&self) -> &str {
        &self.name
    }

    fn is_proxy(&self) -> bool {
        true
    }

    fn get_shared_buffer(&self) -> Option<alloc::sync::Arc<spin::Mutex<alloc::vec::Vec<u32>>>> {
        Some(self.shared_buffer.clone())
    }

    fn draw(&mut self, _screen: &Screen, _win_x: u32, _win_y: u32, _win_w: u32, _win_h: u32) {
        // ProxyApp 自体の draw() は、Core 0 側の draw_windows で ProxyApp を検知して
        // 特殊な memcpy 処理を行うため、ここでは何もしない（あるいは no-op）。
    }

    fn on_mouse(&mut self, local_x: i32, local_y: i32, btn_left: bool, btn_right: bool, wheel: i32) {
        let mut q = self.event_queue.lock();
        q.push(AppEvent::Mouse {
            local_x,
            local_y,
            btn_left,
            btn_right,
            wheel,
        });
    }

    fn on_key(&mut self, keycode: u8, pressed: bool, ascii: Option<char>) {
        let mut q = self.event_queue.lock();
        q.push(AppEvent::Key {
            keycode,
            pressed,
            ascii,
        });
    }

    fn tabs(&self) -> alloc::vec::Vec<alloc::string::String> {
        let t = self.tabs.lock();
        t.clone()
    }

    fn active_tab(&self) -> usize {
        let idx = self.active_tab.lock();
        *idx
    }

    fn switch_tab(&mut self, idx: usize) {
        let mut a = self.active_tab.lock();
        *a = idx;
        let mut q = self.event_queue.lock();
        q.push(AppEvent::SwitchTab(idx));
    }

    fn add_tab(&mut self) {
        let mut q = self.event_queue.lock();
        q.push(AppEvent::AddTab);
    }

    fn close_tab(&mut self, idx: usize) -> bool {
        let mut q = self.event_queue.lock();
        q.push(AppEvent::CloseTab(idx));
        let t = self.tabs.lock();
        t.len() <= 1
    }

    fn needs_timer_redraw(&self) -> bool {
        self.needs_timer_redraw.load(Ordering::Relaxed)
    }

    fn get_buffer_updated_flag(&self) -> Option<alloc::sync::Arc<core::sync::atomic::AtomicBool>> {
        Some(self.buffer_updated.clone())
    }

    fn on_resize(&mut self, width: u32, height: u32) {
        let mut q = self.event_queue.lock();
        q.retain(|e| !matches!(e, AppEvent::Resize { .. }));
        q.push(AppEvent::Resize { width, height });
    }
}

impl Drop for ProxyApp {
    fn drop(&mut self) {
        self.is_alive.store(false, Ordering::Relaxed);
    }
}

pub struct AppRunnerParams {
    pub app: Box<dyn App>,
    pub shared_buffer: Arc<Mutex<Vec<u32>>>,
    pub event_queue: Arc<Mutex<Vec<AppEvent>>>,
    pub is_alive: Arc<AtomicBool>,
    pub active_tab: Arc<Mutex<usize>>,
    pub tabs: Arc<Mutex<Vec<String>>>,
    pub needs_timer_redraw: Arc<AtomicBool>,
    /// shared_buffer 更新通知フラグ（Core 0 への dirty 伝達用）
    pub buffer_updated: Arc<AtomicBool>,
    pub width: u32,
    pub height: u32,
}

/// アプリのスレッドが描いている共有バッファ（画面へ出すウィンドウのバッファ）。
/// 動画の再生スレッドが、アプリの描画が詰まっている間もフレームを直接書くために使う
/// （`web_engine::video` の動画レイヤ）。
#[derive(Clone)]
pub struct DrawTarget {
    pub buffer: Arc<Mutex<Vec<u32>>>,
    pub width: u32,
    pub height: u32,
    pub updated: Arc<AtomicBool>,
}

/// プロセス ID → そのアプリのスレッドの描画先。`app_runner_entry` が登録・更新・削除する。
static DRAW_TARGETS: Mutex<alloc::collections::BTreeMap<usize, DrawTarget>> =
    Mutex::new(alloc::collections::BTreeMap::new());

/// 今のスレッド（アプリの描画中）の描画先。
pub fn current_draw_target() -> Option<DrawTarget> {
    let pid = crate::kernel::scheduler::get_current_process_id()?;
    DRAW_TARGETS.lock().get(&pid).cloned()
}

fn register_draw_target(params: &AppRunnerParams, w: u32, h: u32) {
    if let Some(pid) = crate::kernel::scheduler::get_current_process_id() {
        DRAW_TARGETS.lock().insert(
            pid,
            DrawTarget { buffer: params.shared_buffer.clone(), width: w, height: h, updated: params.buffer_updated.clone() },
        );
    }
}

pub fn app_runner_entry(arg: usize) {
    let params_ptr = arg as *mut AppRunnerParams;
    let mut params = unsafe { Box::from_raw(params_ptr) };

    let mut w = params.width;
    let mut h = params.height;

    // スレッドローカルなバックバッファを用意してロック競合を回避
    let mut local_buf = alloc::vec![0u32; (w * h) as usize];
    register_draw_target(&params, w, h);

    let mut last_draw_time = 0;

    while params.is_alive.load(Ordering::Relaxed) {
        let current_time = crate::kernel::timer::get_ticks();

        // OS側に現在のアプリの needs_timer_redraw 状態をアトミックに同期
        let app_needs_timer = params.app.needs_timer_redraw();
        params.needs_timer_redraw.store(app_needs_timer, Ordering::Relaxed);

        // 1. イベントの処理
        let events = {
            let mut q = params.event_queue.lock();
            let evts = q.clone();
            q.clear();
            evts
        };

        let mut need_redraw = false;

        for evt in events {
            match evt {
                AppEvent::Mouse { local_x, local_y, btn_left, btn_right, wheel } => {
                    params.app.on_mouse(local_x, local_y, btn_left, btn_right, wheel);
                    if btn_left || btn_right || wheel != 0 {
                        need_redraw = true;
                    }
                }
                AppEvent::Key { keycode, pressed, ascii } => {
                    params.app.on_key(keycode, pressed, ascii);
                    need_redraw = true;
                }
                AppEvent::SwitchTab(idx) => {
                    params.app.switch_tab(idx);
                    need_redraw = true;
                }
                AppEvent::AddTab => {
                    params.app.add_tab();
                    need_redraw = true;
                }
                AppEvent::CloseTab(idx) => {
                    let _ = params.app.close_tab(idx);
                    need_redraw = true;
                }
                AppEvent::Resize { width, height } => {
                    w = width;
                    h = height;
                    local_buf = alloc::vec![0u32; (w * h) as usize];
                    {
                        let mut shared = params.shared_buffer.lock();
                        *shared = alloc::vec![0u32; (w * h) as usize];
                    }
                    params.app.on_resize(w, h);
                    register_draw_target(&params, w, h);
                    need_redraw = true;
                }
            }
        }

        // 定期同期
        {
            let mut t = params.tabs.lock();
            *t = params.app.tabs();
        }
        {
            let mut a = params.active_tab.lock();
            *a = params.app.active_tab();
        }

        if params.app.needs_timer_redraw() {
            need_redraw = true;
        }

        let time_since_last_draw = current_time.saturating_sub(last_draw_time);

        // 描画レートを最大30fps（33ms）程度に制限し、かつ不要な背景全クリアを削除してチラつきを完全防止！
        if need_redraw || time_since_last_draw >= 33 {
            // 2. アプリの描画 (ローカルバッファに対して行うため、描画中にロックを保持しない)
            {
                let screen = Screen::new(local_buf.as_mut_ptr(), w, h, w * 4);
                let tab_list = params.app.tabs();
                let has_tabs = !tab_list.is_empty();
                let tab_w = if has_tabs { 100 } else { 0 };
                let app_x = tab_w;
                let app_y = 31u32;
                let app_w = w.saturating_sub(tab_w);
                let app_h = h.saturating_sub(31);

                screen.set_clip(app_x, app_y, w, h);
                params.app.draw(&screen, app_x, app_y, app_w, app_h);
                screen.clear_clip();
            }

            // 3. 描画完了後、一瞬だけ共有バッファに一括コピーする（保持時間を極小化）
            {
                let mut buf_guard = params.shared_buffer.lock();
                if buf_guard.len() == local_buf.len() {
                    buf_guard.copy_from_slice(&local_buf);
                    // ★ Core 0 に「バッファが更新された」ことを通知する
                    // Ordering::Release で書き込み順序を保証し、Core 0 側の Acquire と対になる
                    params.buffer_updated.store(true, Ordering::Release);
                } else {
                    // 【2026-07-26診断】長さ不一致だと**黙って転送をスキップ**していた。
                    // ウィンドウリサイズ等で共有バッファとローカルバッファの大きさが
                    // ずれると、以降アプリの描画結果が一切画面へ反映されなくなる
                    // （画面には古いフレームが residual として残り続ける）。
                    // 「ピクセルは書き込まれているのに画面に出ない」症状の
                    // 有力な候補なので、発生を可視化する。
                    static SKIP_DIAG: core::sync::atomic::AtomicU32 =
                        core::sync::atomic::AtomicU32::new(0);
                    let n = SKIP_DIAG.fetch_add(1, Ordering::Relaxed);
                    if n < 4 || n.is_multiple_of(64) {
                        crate::warn!(
                            "[WM][DIAG] shared_buffer copy SKIPPED (size mismatch): shared={} local={} w={} h={} count={}",
                            buf_guard.len(),
                            local_buf.len(),
                            w,
                            h,
                            n + 1
                        );
                    }
                }
            }

            last_draw_time = current_time;
        }

        // CPU負荷を劇的に下げ、ホストCPUエミュレーションに十分な余裕を残すためのスリープ
        crate::kernel::scheduler::sleep(5);
    }
    if let Some(pid) = crate::kernel::scheduler::get_current_process_id() {
        DRAW_TARGETS.lock().remove(&pid);
    }
}

/// 画面上の1つのウィンドウを表現する
pub struct Window {
    pub x: i32,
    pub y: i32,
    pub width: u32,
    pub height: u32,
    pub title: String,
    pub app: Box<dyn App>,
    pub is_dragging: bool,
    pub drag_offset_x: i32,
    pub drag_offset_y: i32,
    pub buffer: Option<alloc::vec::Vec<u32>>,
    // 空間・マルチタスク拡張
    pub workspace: u8,
    pub is_minimized: bool,
    pub is_fullscreen: bool,
    pub saved_x: i32,
    pub saved_y: i32,
    pub saved_w: u32,
    pub saved_h: u32,
    pub saved_ws: u8,
    /// タブごとのバックグラウンドスレッド PID（None = スレッドなし）
    pub tab_pids: alloc::vec::Vec<Option<usize>>,
}

impl Window {
    pub fn new(x: i32, y: i32, w: u32, h: u32, title: &str, app: Box<dyn App>) -> Self {
        let buffer = alloc::vec![0u32; (w * h) as usize];
        // アプリの初期タブ数だけ PID スロットを確保（最低1）
        let init_tabs = 1;
        Self {
            x,
            y,
            width: w,
            height: h,
            title: String::from(title),
            app,
            is_dragging: false,
            drag_offset_x: 0,
            drag_offset_y: 0,
            buffer: Some(buffer),
            workspace: 1,
            is_minimized: false,
            is_fullscreen: false,
            saved_x: x,
            saved_y: y,
            saved_w: w,
            saved_h: h,
            saved_ws: 1,
            tab_pids: alloc::vec![None; init_tabs],
        }
    }

    /// ウィンドウを new_w × new_h にリサイズする。
    /// バッファは「容量が足りていれば再利用」し、足りない時だけ再確保する（Phase 1: churn 撲滅）。
    /// 再確保時はヒープ残量を確認し、不足ならリサイズを拒否して旧状態を保つ（Phase 2: OOM ガード）。
    /// 描画・合成は stride=width で先頭 width×height 要素のみ使うため、より大きいバッファの再利用は安全。
    /// 戻り値: リサイズに成功したか。
    pub fn resize(&mut self, new_w: u32, new_h: u32) -> bool {
        if new_w == 0 || new_h == 0 {
            return false;
        }
        let needed = (new_w as usize).saturating_mul(new_h as usize);
        let have = self.buffer.as_ref().map(|b| b.len()).unwrap_or(0);

        if have < needed {
            // 拡張が必要: OOM ガード（必要バイト + 64KB の余裕を確認）
            let (used, total) = crate::kernel::allocator::get_heap_stats();
            let free = total.saturating_sub(used);
            let need_bytes = needed.saturating_mul(4).saturating_add(64 * 1024);
            if free < need_bytes {
                crate::println!(
                    "[WM] resize denied: insufficient heap (free {} KB, need {} KB) — keeping current size",
                    free / 1024, need_bytes / 1024
                );
                return false;
            }
            // 旧バッファを先に解放してから確保する（新旧同時確保によるピークを避ける）
            self.buffer = None;
            self.buffer = Some(alloc::vec![0u32; needed]);
        }

        self.width = new_w;
        self.height = new_h;
        self.app.on_resize(new_w, new_h);
        true
    }

    /// タブ idx にスレッドを起動してPIDを記録する
    pub fn spawn_tab_thread(&mut self, tab_idx: usize) {
        while self.tab_pids.len() <= tab_idx {
            self.tab_pids.push(None);
        }
        if let Some(thread_fn) = self.app.tab_thread_fn() {
            let pid = crate::kernel::scheduler::spawn_with_stack(
                thread_fn,
                crate::kernel::scheduler::Priority::Normal,
                "app_tab",
                crate::kernel::scheduler::LARGE_STACK_SIZE,
            );
            if pid != 0 {
                self.tab_pids[tab_idx] = Some(pid);
                crate::info!("[WM] tab {} thread spawned pid={}", tab_idx, pid);
            } else {
                // 【2026-08-25】`spawn` はヒープ不足で 0 を返す。
                // 状態を先に立てていないので壊れはしないが、
                // 黙って何もしないとタブは開いているのに
                // 中身が動かない、という説明の付かない状態になる。
                // 他の 8 箇所と同じく失敗は必ず記録する。
                crate::warn!(
                    "[WM] tab {} のスレッドを起動できません（ヒープ不足）",
                    tab_idx
                );
            }
        }
    }

    /// タブ idx のスレッド PID スロットをクリアする
    /// （スレッド自体はアプリ側の終了フラグで自然に終了させる）
    pub fn clear_tab_thread(&mut self, tab_idx: usize) {
        if tab_idx < self.tab_pids.len() {
            if let Some(pid) = self.tab_pids[tab_idx] {
                crate::info!("[WM] tab {} thread pid={} released", tab_idx, pid);
            }
            self.tab_pids[tab_idx] = None;
        }
    }
}

#[derive(Copy, Clone, Debug)]
pub struct Rect {
    pub x: i32,
    pub y: i32,
    pub w: u32,
    pub h: u32,
}

impl Rect {
    pub fn new(x: i32, y: i32, w: u32, h: u32) -> Self {
        Self { x, y, w, h }
    }

    pub fn union(&self, other: &Self) -> Self {
        let x0 = self.x.min(other.x);
        let y0 = self.y.min(other.y);
        let x1 = (self.x + self.w as i32).max(other.x + other.w as i32);
        let y1 = (self.y + self.h as i32).max(other.y + other.h as i32);
        Self {
            x: x0,
            y: y0,
            w: (x1 - x0).max(0) as u32,
            h: (y1 - y0).max(0) as u32,
        }
    }
}

pub struct WindowManager {
    // リストの最後尾が「最前面（アクティブ）」
    pub windows: Vec<Window>,
    pub dirty: bool,
    pub terminal_focused: bool,
    pub active_workspace: u8,
    pub slide_out: bool,
    pub alt_hold_mode: bool,
    pub alt_input_buffer: String,

    // ダーティ矩形の追跡用
    pub dirty_rects: Vec<Rect>,

    // 直前のマウス状態を記憶してドラッグを判定
    last_mouse_x: i32,
    last_mouse_y: i32,
    last_mouse_btn: bool,
}

// グローバルマネージャ
static mut GLOBAL_WM: Option<ReentrantMutex<WindowManager>> = None;

impl Default for WindowManager {
    fn default() -> Self {
        Self::new()
    }
}

impl WindowManager {
    pub fn new() -> Self {
        Self {
            windows: Vec::new(),
            dirty: true,
            terminal_focused: true,
            active_workspace: 1,
            slide_out: false,
            alt_hold_mode: false,
            alt_input_buffer: String::new(),
            dirty_rects: Vec::new(),
            last_mouse_x: 0,
            last_mouse_y: 0,
            last_mouse_btn: false,
        }
    }

    pub fn add_dirty_rect(&mut self, rect: Rect) {
        self.dirty_rects.push(rect);
    }

    pub fn clear_dirty_rects(&mut self) {
        self.dirty_rects.clear();
    }

    pub fn get_dirty_bounding_box(&self, screen_w: u32, screen_h: u32) -> Option<Rect> {
        if self.dirty_rects.is_empty() {
            return None;
        }
        let mut r = self.dirty_rects[0];
        for i in 1..self.dirty_rects.len() {
            r = r.union(&self.dirty_rects[i]);
        }

        let x0 = r.x.clamp(0, screen_w as i32);
        let y0 = r.y.clamp(0, screen_h as i32);
        let x1 = (r.x + r.w as i32).clamp(0, screen_w as i32);
        let y1 = (r.y + r.h as i32).clamp(0, screen_h as i32);

        Some(Rect::new(x0, y0, (x1 - x0) as u32, (y1 - y0) as u32))
    }

    pub fn add_window(&mut self, mut win: Window) {
        let app_name = win.app.name();
        let mut existing_idx = None;
        for (i, w) in self.windows.iter().enumerate() {
            if w.app.name() == app_name {
                existing_idx = Some(i);
                break;
            }
        }

        if let Some(idx) = existing_idx {
            // 既に同じアプリが起動している場合：最小化解除、ワークスペースへジャンプ、最前面引き上げ
            self.windows[idx].is_minimized = false;
            let target_ws = self.windows[idx].workspace;
            self.active_workspace = target_ws;
            self.activate_window(idx);
            self.dirty = true;
            return;
        }

        // 新規ウィンドウは現在のアクティブワークスペースに割り当て
        win.workspace = self.active_workspace;
        let name = win.title.clone();
        // 初期タブ (index 0) のバックグラウンドスレッドを起動
        win.spawn_tab_thread(0);
        self.add_dirty_rect(Rect::new(win.x, win.y, win.width, win.height));
        self.windows.push(win);
        self.dirty = true;
        self.terminal_focused = false;
        let (used, total) = crate::kernel::allocator::get_heap_stats();
        crate::debug!(
            "[WM] open '{}' -> {} windows | heap {}/{} KB",
            name,
            self.windows.len(),
            used / 1024,
            total / 1024
        );
    }

    pub fn remove_active_window(&mut self) {
        if !self.windows.is_empty() {
            let name = self
                .windows
                .last()
                .map(|w| w.title.clone())
                .unwrap_or_else(|| alloc::string::String::from("?"));
            // ウォッチドッグ of 違反/Not Responding 状態をリセット
            let info = self.windows.last().map(|w| {
                (
                    Rect::new(w.x, w.y, w.width, w.height),
                    alloc::string::String::from(w.app.name()),
                )
            });
            if let Some((rect, app_name)) = info {
                self.add_dirty_rect(rect);
                crate::kernel::watchdog::clear(&app_name);
            }
            self.windows.pop();
            self.dirty = true;
            let (used, total) = crate::kernel::allocator::get_heap_stats();
            crate::debug!(
                "[WM] close '{}' -> {} windows | heap {}/{} KB",
                name,
                self.windows.len(),
                used / 1024,
                total / 1024
            );
        }
    }

    /// 指定したインデックス of ウィンドウを最前面に移動してアクティブにする
    pub fn activate_window(&mut self, idx: usize) {
        // インデックスの境界チェックを行い、範囲外アクセスによる unwrap のパニックや
        // 境界外例外を防止して安全にウィンドウをアクティブ化します。
        if idx < self.windows.len() {
            let target_ws = self.windows[idx].workspace;
            self.active_workspace = target_ws;
            self.terminal_focused = false;
            // ウィンドウを前面に出す際、退避（スライドアウト）状態を解除して
            // 確実に画面内・最前面へ復帰させる。
            self.slide_out = false;
            let win = self.windows.remove(idx);
            let rect = Rect::new(win.x, win.y, win.width, win.height);
            self.add_dirty_rect(rect);
            self.windows.push(win);
            self.add_dirty_rect(rect);
            self.dirty = true;
        }
    }

    /// 全画面（背景の上にウィンドウ）を描画 (合成ウィンドウマネージャ方式)
    /// 指定矩形 (スクリーン座標) を、可視ウィンドウ (アクティブ WS・非最小化) が
    /// 少しでも覆っているかを返す。
    ///
    /// システムモニタのような「背景レイヤー」要素を部分再描画してよいかの判定に使う。
    /// 背景要素はウィンドウより下の z 順にあるため、ウィンドウが覆っている領域へ
    /// 単独で描画すると z 順を破ってウィンドウを突き破ってしまう。それを防ぐ。
    pub fn any_window_covers_rect(&self, x0: i32, y0: i32, x1: i32, y1: i32) -> bool {
        // スライドアウト中 (WS1) は全ウィンドウが画面外へ退避しているため覆わない
        if self.active_workspace == 1 && self.slide_out {
            return false;
        }
        for win in self.windows.iter() {
            if win.workspace != self.active_workspace || win.is_minimized {
                continue;
            }
            let wx1 = win.x + win.width as i32;
            let wy1 = win.y + win.height as i32;
            // 矩形交差判定
            if win.x < x1 && wx1 > x0 && win.y < y1 && wy1 > y0 {
                return true;
            }
        }
        false
    }

    pub fn draw_all(&mut self, screen: &Screen) {
        self.dirty = false;
        let config = crate::kernel::config::get_config();
        let base_frame_color = Color(config.theme.non_active_window_border);
        let title_bar_color = Color(config.theme.window_title_bar);
        let title_fg_color = Color(config.theme.window_title_fg);
        let active_frame_color = Color(config.theme.active_window_border);

        let num_windows = self.windows.len();
        for (i, win) in self.windows.iter_mut().enumerate() {
            // アクティブなワークスペースかつ最小化されていないウィンドウのみを描画
            if win.workspace != self.active_workspace || win.is_minimized {
                continue;
            }
            let is_active = i == num_windows.saturating_sub(1) && !self.terminal_focused;
            let current_frame_color = if is_active {
                active_frame_color
            } else {
                base_frame_color
            };
            let border_w = 2; // 常に2pxの極太ボーダー

            let w = win.width;
            let h = win.height;

            if let Some(ref mut win_buf) = win.buffer {
                // 1. 描画先をウィンドウ固有のバッファに切り替える
                screen.set_render_target(win_buf.as_mut_ptr(), w, h);

                // アプリケーション領域のレイアウト計算（描画前に確定させる）
                let mut tab_list = win.app.tabs();
                let active_idx = win.app.active_tab();
                let is_terminal = win.app.name() == "Terminal";
                if is_terminal && tab_list.is_empty() {
                    tab_list.push(alloc::string::String::from("Shell"));
                }
                let has_tabs = !tab_list.is_empty();
                let tab_w = if has_tabs { 100 } else { 0 };
                let app_x = tab_w;
                let app_y = 31u32;
                let app_w = w.saturating_sub(tab_w);
                let _app_h = h.saturating_sub(31);

                let app_name = win.app.name();

                // 【2026-07-27診断】表示フレームの通し番号を進め、
                // 「ヒーロー文字を最後に描いたフレーム」との差を可視化する。
                // 差が開き続けるなら、文字を描いたフレームは画面に出ていない。
                {
                    let f = crate::kernel::draw::FRAME_NO
                        .fetch_add(1, Ordering::Relaxed)
                        .wrapping_add(1);
                    if f.is_multiple_of(64) {
                        // 【2026-08-25】取得の待機状態はここから出す。
                        //
                        // 最初はブラウザの `draw()` から出していたが、
                        // **待機に入ると `draw()` 自体が止まる**ので
                        // 最後に出た行が古い標本のまま残り、
                        // 「まだ取得中」に見えたまま更新されなくなった。
                        // 採取スクリプトはこの行で撮影時期を決めるので、
                        // 止まらない側（画面の提示ループ）から出す必要がある。
                        crate::os_lib::web_engine::fetch_limit::idle_line();
                        let ht = crate::kernel::draw::HERO_TEXT_FRAME.load(Ordering::Relaxed);
                        crate::warn!(
                            "[WM][FRAME] present_frame={} last_hero_text_frame={}",
                            f,
                            if ht == u32::MAX { 0 } else { ht }
                        );
                    }
                }

                if win.app.is_proxy() {
                    // ★ ProxyApp の描画順序：
                    //   ① shared_buf → win_buf の全面コピー（前フレームの内容で埋める）
                    //   ② タイトルバー・枠線を上書き
                    // これにより「一瞬 app_bg 単色状態」が発生せずちらつきを防止する。
                    if let Some(shared_buf_arc) = win.app.get_shared_buffer() {
                        if let Some(shared_buf) = shared_buf_arc.try_lock() {
                            // shared_buf は app_runner が w×h 全面に描画済みなので全コピー
                            let copy_len = (w * h) as usize;
                            if shared_buf.len() >= copy_len && win_buf.len() >= copy_len {
                                unsafe {
                                    core::ptr::copy_nonoverlapping(
                                        shared_buf.as_ptr(),
                                        win_buf.as_mut_ptr(),
                                        copy_len,
                                    );
                                }
                            } else {
                                // 【2026-07-26診断】ここも長さ不足だと**黙ってスキップ**して
                                // win_buf の前フレーム内容をそのまま表示し続ける。
                                // アプリ側(app_runner)の転送は成功しているのに画面が
                                // 更新されない、という症状の候補。発生を可視化する。
                                static CSKIP: core::sync::atomic::AtomicU32 =
                                    core::sync::atomic::AtomicU32::new(0);
                                let n = CSKIP.fetch_add(1, Ordering::Relaxed);
                                if n < 4 || n.is_multiple_of(128) {
                                    crate::warn!(
                                        "[WM][DIAG] compositor copy SKIPPED: shared={} win_buf={} need={} (w={} h={}) count={}",
                                        shared_buf.len(),
                                        win_buf.len(),
                                        copy_len,
                                        w,
                                        h,
                                        n + 1
                                    );
                                }
                            }
                        } else {
                            // try_lock 失敗 = app_runner 側が書き込み中。
                            // win_buf の前フレーム内容をそのまま使い、次フレームでリトライ。
                            //
                            // 【2026-07-26診断】ここが連続して失敗し続けると
                            // **古いフレームを表示し続ける**。ブラウザのように
                            // 1 フレームの描画が重いアプリでは app_runner が
                            // ロックを長く保持するため、コンポジタが毎回負ける
                            // 可能性がある。成功率を可視化する。
                            static TRYLOCK_FAIL: core::sync::atomic::AtomicU32 =
                                core::sync::atomic::AtomicU32::new(0);
                            let n = TRYLOCK_FAIL.fetch_add(1, Ordering::Relaxed);
                            if n < 4 || n.is_multiple_of(128) {
                                crate::warn!(
                                    "[WM][DIAG] compositor try_lock FAILED (using stale frame) count={}",
                                    n + 1
                                );
                            }
                            self.dirty = true;
                        }
                    }
                } else {
                    // 2. 非Proxy: 従来通りバッファをクリアしてからアプリが描画
                    screen.boxfill(0, 0, w, h, Color(config.theme.app_bg)); // 背景

                    // アプリの描画（ウォッチドッグで監視）
                    screen.set_clip(app_x, app_y, w, h);
                    if crate::kernel::watchdog::is_not_responding(app_name) {
                        screen.boxfill(app_x, app_y, w, h, Color(config.theme.ui_overlay_bg));
                        screen.draw_string_vector(
                            app_x + 16,
                            app_y + 16,
                            "Application Not Responding",
                            Color(config.theme.error_fg),
                            16,
                        );
                        screen.draw_string_vector(
                            app_x + 16,
                            app_y + 40,
                            "Close the window (Alt+W) to recover.",
                            Color(config.theme.terminal_fg),
                            13,
                        );
                    } else {
                        crate::kernel::watchdog::enter(app_name);
                        win.app.draw(screen, app_x, app_y, app_w, _app_h);
                        crate::kernel::watchdog::exit();
                    }
                    screen.clear_clip();
                }

                // 3. タイトルバー・枠線・ボタンを最前面に上書き（ProxyApp でも共通）
                // タイトルバー (高さ30px)
                screen.boxfill(0, 0, w, 30, title_bar_color);

                // 境界線 (Premium Border Highlight with 立体極暗シャドウ)
                let shadow_color = Color(0xFF111217);
                screen.boxfill(0, 0, w, 1, shadow_color); // 最上部極暗
                screen.boxfill(0, 0, 1, h, shadow_color); // 最左部極暗
                screen.boxfill(w - 1, 0, w, h, shadow_color); // 最右部極暗
                screen.boxfill(0, h - 1, w, h, shadow_color); // 最下部極暗

                screen.boxfill(1, 1, w - 1, 1 + border_w, current_frame_color); // 上
                screen.boxfill(1, 1, 1 + border_w, h - 1, current_frame_color); // 左
                screen.boxfill(w - 1 - border_w, 1, w - 1, h - 1, current_frame_color); // 右
                screen.boxfill(1, h - 1 - border_w, w - 1, h - 1, current_frame_color); // 下
                screen.boxfill(1, 30, w - 1, 30 + border_w, current_frame_color); // タイトル下

                // タイトルテキスト
                screen.draw_string_vector(10, 5, &win.title, title_fg_color, 16);

                // ウィンドウ制御ボタン群 (右から順に配置) - Fluent UI System Icons (MIT)
                static ICON_CLOSE: &[u8] =
                    include_bytes!("../../icons/ic_fluent_dismiss_circle_20_regular.svg");
                static ICON_FS: &[u8] =
                    include_bytes!("../../icons/ic_fluent_full_screen_maximize_20_regular.svg");
                static ICON_MAX: &[u8] =
                    include_bytes!("../../icons/ic_fluent_maximize_20_regular.svg");
                static ICON_NORM: &[u8] =
                    include_bytes!("../../icons/ic_fluent_full_screen_minimize_20_regular.svg");
                static ICON_MIN: &[u8] =
                    include_bytes!("../../icons/ic_fluent_subtract_circle_20_regular.svg");

                let btn_w = 20u32;
                let _btn_h = 20u32;
                let btn_y = 5u32;
                let gap = 5i32;

                // [X] 閉じるボタン
                let bx_close = w - 10 - btn_w;
                screen.draw_svg_icon(bx_close, btn_y, ICON_CLOSE, btn_w, Color(config.theme.win_btn_close));

                // [F] フルスクリーンボタン
                let bx_fs = (bx_close as i32 - btn_w as i32 - gap) as u32;
                screen.draw_svg_icon(bx_fs, btn_y, ICON_FS, btn_w, Color(config.theme.win_btn_fullscreen));

                // [M] 最大化ボタン
                let bx_max = (bx_fs as i32 - btn_w as i32 - gap) as u32;
                screen.draw_svg_icon(bx_max, btn_y, ICON_MAX, btn_w, Color(config.theme.win_btn_maximize));

                // [N] 通常化ボタン
                let bx_norm = (bx_max as i32 - btn_w as i32 - gap) as u32;
                screen.draw_svg_icon(bx_norm, btn_y, ICON_NORM, btn_w, Color(config.theme.win_btn_restore));

                // [m] 最小化ボタン
                let bx_min = (bx_norm as i32 - btn_w as i32 - gap) as u32;
                screen.draw_svg_icon(bx_min, btn_y, ICON_MIN, btn_w, Color(config.theme.win_btn_minimize));

                // ウィンドウ内タブの描画（ProxyApp・非Proxy 共通）
                if has_tabs {
                    screen.boxfill(0, app_y, tab_w, h, Color(config.theme.tab_area_bg));
                    screen.boxfill(tab_w - 1, app_y, tab_w, h, Color(config.theme.tab_area_border)); // 境界線

                    screen.draw_string_vector(10, app_y + 10, "TABS", Color(config.theme.tab_inactive_fg), 14);

                    // (+) button
                    screen.boxfill(75, app_y + 8, 92, app_y + 25, Color(config.theme.tab_area_border));
                    screen.draw_string_vector(80, app_y + 10, "+", Color(config.theme.tab_active_fg), 14);

                    screen.boxfill(10, app_y + 30, 90, app_y + 31, Color(config.theme.tab_area_border));

                    let mut tab_y = app_y + 40;
                    for (idx, tab_title) in tab_list.iter().enumerate() {
                        if tab_y + 42 > h {
                            break;
                        }

                        let is_active_tab = idx == active_idx;
                        let bg_color = if is_active_tab {
                            Color(config.theme.tab_active_bg)
                        } else {
                            Color(config.theme.tab_area_bg)
                        };
                        let fg_color = if is_active_tab {
                            Color(config.theme.tab_active_fg)
                        } else {
                            Color(config.theme.tab_inactive_fg)
                        };

                        screen.boxfill(5, tab_y, 95, tab_y + 36, bg_color);

                        let label = alloc::format!("{})", idx + 1);
                        screen.draw_string_vector(10, tab_y + 12, &label, fg_color, 12);

                        // 改行許容および文字数拡大ロジック
                        let mut lines = alloc::vec![];
                        if tab_title.contains('\n') {
                            for (count, part) in tab_title.split('\n').enumerate() {
                                if count >= 2 {
                                    break;
                                }
                                lines.push(alloc::string::String::from(part));
                            }
                        } else {
                            let chars: alloc::vec::Vec<char> = tab_title.chars().collect();
                            if chars.len() <= 6 {
                                lines.push(tab_title.clone());
                            } else {
                                let first: alloc::string::String = chars.iter().take(6).collect();
                                let mut second: alloc::string::String =
                                    chars.iter().skip(6).collect();
                                if second.chars().count() > 6 {
                                    let mut sec_trunc: alloc::string::String =
                                        second.chars().take(4).collect();
                                    sec_trunc.push_str("..");
                                    second = sec_trunc;
                                }
                                lines.push(first);
                                lines.push(second);
                            }
                        }

                        if lines.len() == 1 {
                            screen.draw_string_vector(22, tab_y + 12, &lines[0], fg_color, 10);
                        } else if lines.len() >= 2 {
                            screen.draw_string_vector(22, tab_y + 5, &lines[0], fg_color, 10);
                            screen.draw_string_vector(22, tab_y + 19, &lines[1], fg_color, 10);
                        }

                        // (x) button
                        screen.boxfill(78, tab_y + 10, 92, tab_y + 24, Color(config.theme.tab_area_border));
                        screen.draw_string_vector(82, tab_y + 12, "x", Color(config.theme.win_btn_close), 10);

                        tab_y += 42;
                    }
                }

                // 4. 描画ターゲットをメイン画面バッファへリセット
                screen.reset_render_target();

                // 5. win_buf → back_buffer へ行単位の高速コピー（ピクセルループを廃止）
                let screen_w = screen.width;
                let screen_h = screen.height;
                let main_ptr = if screen.use_back_buffer.get() && !screen.back_buffer.is_null() {
                    screen.back_buffer
                } else {
                    screen.vram
                };

                let win_x = if self.active_workspace == 1 && self.slide_out {
                    win.x + screen.width as i32
                } else {
                    win.x
                };
                let win_y = win.y;

                // クリップ計算（ウィンドウが画面端にかかる場合、および画面のダーティクリップ領域に対応）
                let src_x0 = if win_x < 0 { (-win_x) as u32 } else { 0 };
                let src_y0 = if win_y < 0 { (-win_y) as u32 } else { 0 };
                let dst_x0 = win_x.max(0) as u32;
                let dst_y0 = win_y.max(0) as u32;
                let copy_w = w.saturating_sub(src_x0).min(screen_w.saturating_sub(dst_x0));
                let copy_h = h.saturating_sub(src_y0).min(screen_h.saturating_sub(dst_y0));

                let (clip_x0, clip_y0, clip_x1, clip_y1) = if let Some(c) = screen.clip.get() {
                    c
                } else {
                    (0, 0, screen_w, screen_h)
                };
                let eff_dst_x0 = dst_x0.max(clip_x0);
                let eff_dst_y0 = dst_y0.max(clip_y0);
                let eff_dst_x1 = (dst_x0 + copy_w).min(clip_x1);
                let eff_dst_y1 = (dst_y0 + copy_h).min(clip_y1);

                if eff_dst_x1 > eff_dst_x0 && eff_dst_y1 > eff_dst_y0 {
                    let eff_w = eff_dst_x1 - eff_dst_x0;
                    let eff_h = eff_dst_y1 - eff_dst_y0;
                    let eff_src_x0 = src_x0 + (eff_dst_x0 - dst_x0);
                    let eff_src_y0 = src_y0 + (eff_dst_y0 - dst_y0);
                    unsafe {
                        for row in 0..eff_h {
                            let src_ptr = win_buf.as_ptr().add(((eff_src_y0 + row) * w + eff_src_x0) as usize);
                            let dst_ptr = main_ptr.add(((eff_dst_y0 + row) * screen_w + eff_dst_x0) as usize);
                            core::ptr::copy_nonoverlapping(src_ptr, dst_ptr, eff_w as usize);
                        }
                    }
                }
            }
        }

        // 6. Altホールド複数桁遅延実行オーバーレイの描画
        if self.alt_hold_mode {
            let overlay_w = 200u32;
            let overlay_h = 100u32;
            let overlay_x = (screen.width - overlay_w) / 2;
            let overlay_y = (screen.height - overlay_h) / 2;

            let overlay_bg_semi = Color(0xEE000000 | (config.theme.ui_overlay_bg & 0x00FFFFFF));
            screen.boxfill(
                overlay_x,
                overlay_y,
                overlay_x + overlay_w,
                overlay_y + overlay_h,
                overlay_bg_semi,
            );
            screen.boxfill(
                overlay_x,
                overlay_y,
                overlay_x + overlay_w,
                overlay_y + 2,
                Color(config.theme.ui_overlay_accent),
            );
            screen.draw_string_vector(
                overlay_x + 15,
                overlay_y + 10,
                "STATELESS JUMP",
                Color(config.theme.terminal_fg),
                14,
            );

            let val_str = if self.alt_input_buffer.is_empty() {
                alloc::string::String::from("_")
            } else {
                alloc::format!("{}_", self.alt_input_buffer)
            };
            screen.draw_string_vector(
                overlay_x + 80,
                overlay_y + 40,
                &val_str,
                Color(config.theme.success_fg),
                32,
            );
        }
    }

    /// マウスイベント処理。Zオーダー順（手前から）判定する。
    pub fn handle_mouse(
        &mut self,
        mx: i32,
        my: i32,
        btn_left: bool,
        btn_right: bool,
        wheel: i32,
        screen: &Screen,
    ) -> bool {
        let mut handled = false;

        let dx = mx - self.last_mouse_x;
        let dy = my - self.last_mouse_y;

        // 1. ドラッグ中のウィンドウがあれば移動 (アクティブなワークスペースかつ非最小化時のみ)
        // 1. ドラッグ中のウィンドウがあれば移動 (アクティブなワークスペースかつ非最小化時のみ)
        let is_dragging = if let Some(win) = self.windows.last() {
            win.is_dragging && win.workspace == self.active_workspace && !win.is_minimized
        } else {
            false
        };

        if is_dragging {
            if btn_left {
                // 移動前の矩形をダーティ登録
                let old_rect = if let Some(win) = self.windows.last() {
                    Rect::new(win.x, win.y, win.width, win.height)
                } else {
                    Rect::new(0, 0, 0, 0)
                };
                self.add_dirty_rect(old_rect);

                if let Some(win) = self.windows.last_mut() {
                    win.x += dx;
                    win.y += dy;
                }
                self.dirty = true;

                // 移動後の矩形をダーティ登録
                let new_rect = if let Some(win) = self.windows.last() {
                    Rect::new(win.x, win.y, win.width, win.height)
                } else {
                    Rect::new(0, 0, 0, 0)
                };
                self.add_dirty_rect(new_rect);

                self.last_mouse_x = mx;
                self.last_mouse_y = my;
                self.last_mouse_btn = btn_left;
                return true;
            } else {
                if let Some(win) = self.windows.last_mut() {
                    win.is_dragging = false;
                }
            }
        }

        // 2. マウスクリック時のヒットテスト（手前から奥へ）
        let btn_just_pressed = btn_left && !self.last_mouse_btn;
        let mut target_index = None;
        let mut close_clicked = false;
        let mut fs_clicked = false;
        let mut max_clicked = false;
        let mut norm_clicked = false;
        let mut min_clicked = false;

        for (i, win) in self.windows.iter_mut().enumerate().rev() {
            // 現在アクティブな空間かつ非最小化ウィンドウのみを対象とする
            if win.workspace != self.active_workspace || win.is_minimized {
                continue;
            }
            let win_x = if self.active_workspace == 1 && self.slide_out {
                win.x + 2000 // 画面外へ
            } else {
                win.x
            };
            if mx >= win_x
                && mx <= win_x + win.width as i32
                && my >= win.y
                && my <= win.y + win.height as i32
            {
                target_index = Some(i);

                // タイトルバー判定 (Y: 0..30)
                if my < win.y + 30 {
                    let btn_w = 20;
                    let gap = 5;
                    let bx_close = win_x + win.width as i32 - 10 - btn_w;
                    let bx_fs = bx_close - btn_w - gap;
                    let bx_max = bx_fs - btn_w - gap;
                    let bx_norm = bx_max - btn_w - gap;
                    let bx_min = bx_norm - btn_w - gap;

                    if btn_just_pressed {
                        if mx >= bx_close && mx <= bx_close + btn_w {
                            close_clicked = true;
                        } else if mx >= bx_fs && mx <= bx_fs + btn_w {
                            fs_clicked = true;
                        } else if mx >= bx_max && mx <= bx_max + btn_w {
                            max_clicked = true;
                        } else if mx >= bx_norm && mx <= bx_norm + btn_w {
                            norm_clicked = true;
                        } else if mx >= bx_min && mx <= bx_min + btn_w {
                            min_clicked = true;
                        } else {
                            // タイトルバークリックでドラッグ開始
                            win.is_dragging = true;
                            win.drag_offset_x = mx - win.x;
                            win.drag_offset_y = my - win.y;
                        }
                    }
                } else {
                    let mut tab_list = win.app.tabs();
                    let is_terminal = win.app.name() == "Terminal";
                    if is_terminal && tab_list.is_empty() {
                        tab_list.push(alloc::string::String::from("Shell"));
                    }
                    let has_tabs = !tab_list.is_empty();
                    let tab_w = if has_tabs { 100 } else { 0 };

                    let local_x = mx - win_x;
                    let local_y = my - (win.y + 31);

                    if has_tabs && local_x < tab_w {
                        // タブ領域のクリック処理
                        if btn_just_pressed {
                            let tab_y_click = local_y as u32;
                            if (8..=25).contains(&tab_y_click) && (75..=92).contains(&local_x) {
                                // '+' ボタン: タブ追加 → バックグラウンドスレッド起動
                                let new_tab_idx = win.app.tabs().len();
                                win.app.add_tab();
                                win.spawn_tab_thread(new_tab_idx);
                                self.dirty = true;
                                crate::kernel::audio::play_system_se(
                                    crate::kernel::audio::SeType::Apply,
                                );
                            } else if tab_y_click >= 40 {
                                let clicked_tab = ((tab_y_click - 40) / 42) as usize;
                                if clicked_tab < tab_list.len() {
                                    let relative_y = (tab_y_click - 40) % 42;
                                    if relative_y <= 36 {
                                        if (78..=92).contains(&local_x)
                                            && (10..=24).contains(&relative_y)
                                        {
                                            // 'x' ボタン: タブ削除 → スレッドを解放
                                            win.clear_tab_thread(clicked_tab);
                                            let should_close = win.app.close_tab(clicked_tab);
                                            if should_close {
                                                close_clicked = true;
                                            } else {
                                                crate::kernel::audio::play_system_se(
                                                    crate::kernel::audio::SeType::Apply,
                                                );
                                            }
                                        } else {
                                            win.app.switch_tab(clicked_tab);
                                        }
                                        self.dirty = true;
                                    }
                                }
                            }
                        }
                    } else {
                        // アプリ内部の処理（ローカルX座標はタブ幅分シフトする）
                        win.app
                            .on_mouse(local_x - tab_w, local_y, btn_left, btn_right, wheel);
                        // マウスを動かしただけで全画面再描画すると重くなるため、クリックやスクロール時のみ再描画
                        if btn_just_pressed || wheel != 0 || (btn_left != self.last_mouse_btn) {
                            self.dirty = true;
                        }
                    }
                }

                handled = true;
                break;
            }
        }

        // フォーカス切り替え（アクティブ化）と閉じる・サイズ変更処理
        if let Some(idx) = target_index {
            if btn_just_pressed {
                self.activate_window(idx);
            }
            if close_clicked {
                if let Some(w) = self.windows.last() {
                    self.add_dirty_rect(Rect::new(w.x, w.y, w.width, w.height));
                }
                self.windows.pop();
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Close);
                self.dirty = true;
                if self.windows.is_empty() {
                    self.terminal_focused = true;
                }
            } else if fs_clicked {
                // 1. 空いているワークスペースを探す（2〜8）
                let mut target_ws = None;
                for ws in 2..=8 {
                    let mut used = false;
                    for w in &self.windows {
                        if w.workspace == ws && !w.is_minimized {
                            used = true;
                            break;
                        }
                    }
                    if !used {
                        target_ws = Some(ws);
                        break;
                    }
                }
                let target_ws = target_ws.unwrap_or(self.active_workspace);

                let old_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = old_rect {
                    self.add_dirty_rect(r);
                }

                if let Some(win) = self.windows.last_mut() {
                    win.is_fullscreen = true;
                    win.saved_x = win.x;
                    win.saved_y = win.y;
                    win.saved_w = win.width;
                    win.saved_h = win.height;
                    win.saved_ws = win.workspace;
                    let sw = screen.width;
                    let sh = screen.height;
                    win.x = 0;
                    win.y = 0;
                    win.resize(sw, sh);
                    win.workspace = target_ws;
                    self.active_workspace = target_ws;
                    self.dirty = true;
                }
                let sw = screen.width;
                let sh = screen.height;
                self.add_dirty_rect(Rect::new(0, 0, sw, sh));
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Apply);
            } else if max_clicked {
                let old_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = old_rect {
                    self.add_dirty_rect(r);
                }

                if let Some(win) = self.windows.last_mut() {
                    win.is_fullscreen = false;
                    win.saved_x = win.x;
                    win.saved_y = win.y;
                    win.saved_w = win.width;
                    win.saved_h = win.height;
                    let sh = screen.height.saturating_sub(crate::kernel::fn_bar::BAR_HEIGHT);
                    let sysmon_w = if screen.width >= 1920 { 518 } else { 300 };
                    let max_w = screen.width.saturating_sub(sysmon_w);
                    win.x = 0;
                    win.y = 0;
                    win.resize(max_w, sh);
                    self.dirty = true;
                }

                let new_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = new_rect {
                    self.add_dirty_rect(r);
                }
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Apply);
            } else if norm_clicked {
                let old_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = old_rect {
                    self.add_dirty_rect(r);
                }

                if let Some(win) = self.windows.last_mut() {
                    win.is_fullscreen = false;
                    win.x = win.saved_x;
                    win.y = win.saved_y;
                    let (rw, rh) = (win.saved_w, win.saved_h);

                    self.active_workspace = win.saved_ws;
                    win.workspace = win.saved_ws;

                    win.resize(rw, rh);
                    self.dirty = true;
                }

                let new_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = new_rect {
                    self.add_dirty_rect(r);
                }
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Apply);
            } else if min_clicked {
                let old_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = old_rect {
                    self.add_dirty_rect(r);
                }

                if let Some(win) = self.windows.last_mut() {
                    win.is_minimized = true;
                }
                self.dirty = true;
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Close);
            }
        } else if btn_just_pressed {
            // ウィンドウ外をクリックした場合はターミナル等にフォーカスを戻す
            // ただし、右側ペイン（システムモニター：X >= 1600）をクリックした場合はターミナルにフォーカスを奪わない
            let sysmon_w = if screen.width >= 1920 { 518 } else { 300 };
            let sysmon_x = screen.width - sysmon_w;
            if mx < sysmon_x as i32 {
                self.terminal_focused = true;
            }
        }

        self.last_mouse_x = mx;
        self.last_mouse_y = my;
        self.last_mouse_btn = btn_left;

        handled
    }

    /// キーボードイベントの処理（ファンクションキーおよびアクティブウィンドウ宛て）
    pub fn handle_key(
        &mut self,
        keycode: u8,
        pressed: bool,
        ascii: Option<char>,
        alt_pressed: bool,
        screen: &Screen,
    ) -> bool {
        if !pressed {
            return false;
        }

        // --- ファンクションキーの絶対アサイン判定 ---

        // 1. F1 (単体) & F1 (フォーカス時再押下でウィンドウ退避)
        if keycode == 0x3B && !alt_pressed {
            if self.terminal_focused && !self.slide_out {
                // すでにターミナルが前面・フォーカス中なら、ウィンドウ退避スライドへトグル
                self.slide_out = true;
                self.dirty = true;
            } else {
                // 初回（未フォーカス、または退避中）は一段でターミナルを前面+フォーカス化
                self.terminal_focused = true;
                self.slide_out = false;
                self.dirty = true;
            }
            crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Apply);
            return true;
        }

        // 2. Alt + F1 〜 F8 (空間移動)
        if alt_pressed && (0x3B..=0x42).contains(&keycode) {
            let target_ws = if keycode == 0x3B {
                1
            } else {
                (keycode - 0x3C) + 2
            };
            self.active_workspace = target_ws;
            self.dirty = true;

            // 移動先にウィンドウがあれば最前面をアクティブにする
            let mut last_win_idx = None;
            for (i, win) in self.windows.iter().enumerate() {
                if win.workspace == target_ws && !win.is_minimized {
                    last_win_idx = Some(i);
                }
            }
            if let Some(idx) = last_win_idx {
                self.activate_window(idx);
            } else {
                self.terminal_focused = true;
            }
            crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Apply);
            return true;
        }

        // 3. Alt + F9 (アクティブウィンドウの最小化)
        if alt_pressed && keycode == 0x43 {
            let active_is_matching = if let Some(win) = self.windows.last() {
                win.workspace == self.active_workspace && !win.is_minimized
            } else {
                false
            };

            if active_is_matching {
                let old_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = old_rect {
                    self.add_dirty_rect(r);
                }

                if let Some(win) = self.windows.last_mut() {
                    win.is_minimized = true;
                }
                self.dirty = true;

                // フォーカスを背面のウィンドウまたはターミナルに戻す
                let mut found_next = false;
                let len = self.windows.len();
                if len > 1 {
                    for i in (0..len - 1).rev() {
                        let is_candidate = {
                            let w = &self.windows[i];
                            w.workspace == self.active_workspace && !w.is_minimized
                        };
                        if is_candidate {
                            self.activate_window(i);
                            found_next = true;
                            break;
                        }
                    }
                }
                if !found_next {
                    self.terminal_focused = true;
                }
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Close);
                // 最小化時の音
            }
            return true;
        }

        // 4. Alt + F10 (通常のフローティング状態へ移行)
        if alt_pressed && keycode == 0x44 {
            let matches_ws = if let Some(win) = self.windows.last() {
                win.workspace == self.active_workspace
            } else {
                false
            };

            if matches_ws {
                let old_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = old_rect {
                    self.add_dirty_rect(r);
                }

                if let Some(win) = self.windows.last_mut() {
                    win.is_fullscreen = false;
                    win.x = win.saved_x;
                    win.y = win.saved_y;
                    let (rw, rh) = (win.saved_w, win.saved_h);
                    win.resize(rw, rh);
                }
                self.dirty = true;

                let new_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = new_rect {
                    self.add_dirty_rect(r);
                }
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Apply);
            }
            return true;
        }

        // 5. Alt + F11 (フローティング最大化)
        if alt_pressed && keycode == 0x57 {
            let matches_ws = if let Some(win) = self.windows.last() {
                win.workspace == self.active_workspace
            } else {
                false
            };

            if matches_ws {
                let old_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = old_rect {
                    self.add_dirty_rect(r);
                }

                if let Some(win) = self.windows.last_mut() {
                    if !win.is_fullscreen {
                        win.saved_x = win.x;
                        win.saved_y = win.y;
                        win.saved_w = win.width;
                        win.saved_h = win.height;
                    }

                    // メイン空間表示可能領域 (左端縦タブ100px、右端モニター領域を除く)
                    let sysmon_w = if screen.width >= 1920 { 518 } else { 300 };
                    let avail_w = screen.width.saturating_sub(100 + sysmon_w);
                    win.x = 100;
                    win.y = 0;
                    let sh = screen.height.saturating_sub(crate::kernel::fn_bar::BAR_HEIGHT);
                    win.resize(avail_w, sh);
                }
                self.dirty = true;

                let new_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = new_rect {
                    self.add_dirty_rect(r);
                }
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Apply);
            }
            return true;
        }

        // 6. Alt + F12 (アプリ全体のフルスクリーン化)
        if alt_pressed && keycode == 0x58 {
            // 空きスロット (2..=8) 探索 (可変借用の前に実施して競合を回避)
            let mut target_ws = None;
            for ws in 2..=8 {
                let mut occupied = false;
                for w in &self.windows {
                    if w.workspace == ws && !w.is_minimized {
                        occupied = true;
                        break;
                    }
                }
                if !occupied {
                    target_ws = Some(ws);
                    break;
                }
            }

            if let Some(ws) = target_ws {
                let old_rect = self
                    .windows
                    .last()
                    .map(|win| Rect::new(win.x, win.y, win.width, win.height));
                if let Some(r) = old_rect {
                    self.add_dirty_rect(r);
                }

                if let Some(win) = self.windows.last_mut() {
                    if !win.is_fullscreen {
                        win.saved_x = win.x;
                        win.saved_y = win.y;
                        win.saved_w = win.width;
                        win.saved_h = win.height;
                    }

                    win.is_fullscreen = true;
                    win.workspace = ws;
                    win.x = 0;
                    win.y = 0;
                    let (sw, sh) = (screen.width, screen.height);
                    win.resize(sw, sh);
                }
                self.active_workspace = ws;
                self.dirty = true;
                let (sw, sh) = (screen.width, screen.height);
                self.add_dirty_rect(Rect::new(0, 0, sw, sh));
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Apply);
            } else {
                // 空きスロット上限による拒否 (警告音)
                crate::kernel::audio::play_system_se(crate::kernel::audio::SeType::Close);
            }
            return true;
        }

        // --- 通常のアプリ宛キーイベント送信 ---
        if self.terminal_focused {
            return false;
        }
        let is_active = if let Some(win) = self.windows.last() {
            win.workspace == self.active_workspace && !win.is_minimized
        } else {
            false
        };

        if is_active {
            if let Some(win) = self.windows.last_mut() {
                win.app.on_key(keycode, pressed, ascii);
            }

            let rect = self
                .windows
                .last()
                .map(|win| Rect::new(win.x, win.y, win.width, win.height));
            if let Some(r) = rect {
                self.add_dirty_rect(r);
            }
            self.dirty = true;
            return true;
        }
        false
    }

    /// 何らかのアクティブなウィンドウがタイマー再描画を要求しているか
    pub fn needs_timer_redraw(&self) -> bool {
        for win in &self.windows {
            if win.workspace == self.active_workspace
                && !win.is_minimized
                && win.app.needs_timer_redraw()
            {
                return true;
            }
        }
        false
    }
}

pub fn init() {
    unsafe {
        GLOBAL_WM = Some(ReentrantMutex::new(WindowManager::new()));
    }
}

pub fn get_instance() -> ReentrantMutexGuard<'static, WindowManager> {
    // init() 前に呼ばれた場合も panic せず、その場で初期化する
    unsafe {
        GLOBAL_WM
            .get_or_insert_with(|| ReentrantMutex::new(WindowManager::new()))
            .lock()
    }
}

use core::cell::UnsafeCell;
use core::sync::atomic::{AtomicUsize, Ordering};

pub struct ReentrantMutex<T> {
    inner: UnsafeCell<T>,
    owner: AtomicUsize,
    recursion: AtomicUsize,
}

unsafe impl<T: Send> Send for ReentrantMutex<T> {}
unsafe impl<T: Send> Sync for ReentrantMutex<T> {}

impl<T> ReentrantMutex<T> {
    pub const fn new(value: T) -> Self {
        Self {
            inner: UnsafeCell::new(value),
            owner: AtomicUsize::new(usize::MAX),
            recursion: AtomicUsize::new(0),
        }
    }

    pub fn lock(&self) -> ReentrantMutexGuard<'_, T> {
        let cid = crate::kernel::scheduler::core_id();
        loop {
            if self.owner.load(Ordering::Relaxed) == cid {
                self.recursion.fetch_add(1, Ordering::Relaxed);
                return ReentrantMutexGuard { mutex: self };
            }
            if self
                .owner
                .compare_exchange_weak(usize::MAX, cid, Ordering::Acquire, Ordering::Relaxed)
                .is_ok()
            {
                self.recursion.store(1, Ordering::Relaxed);
                return ReentrantMutexGuard { mutex: self };
            }
            core::hint::spin_loop();
        }
    }
}

pub struct ReentrantMutexGuard<'a, T> {
    mutex: &'a ReentrantMutex<T>,
}

impl<'a, T> core::ops::Deref for ReentrantMutexGuard<'a, T> {
    type Target = T;
    fn deref(&self) -> &Self::Target {
        unsafe { &*self.mutex.inner.get() }
    }
}

impl<'a, T> core::ops::DerefMut for ReentrantMutexGuard<'a, T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        unsafe { &mut *self.mutex.inner.get() }
    }
}

impl<'a, T> Drop for ReentrantMutexGuard<'a, T> {
    fn drop(&mut self) {
        let rec = self.mutex.recursion.fetch_sub(1, Ordering::Relaxed);
        if rec == 1 {
            self.mutex.owner.store(usize::MAX, Ordering::Release);
        }
    }
}