atmos/kernel/

window.rs

// src/window.rs - システムモニター用右側固定ペインの描画管理
#![allow(dead_code)]
#![allow(static_mut_refs)]

extern crate alloc;
use alloc::format;
use alloc::string::String;

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

#[derive(Clone, Copy, PartialEq, Eq)]
pub enum SortColumn {
    Name,
    Cpu,
    Ram,
    Info,
}

pub struct SystemMonitorPane {
    pub x: i32,
    pub y: i32,
    pub width: u32,
    pub height: u32,
    pub last_update_ticks: usize,
    pub sort_col: SortColumn,
    pub sort_asc: bool,
    pub selected_idx: Option<usize>,
    pub focused: bool,
    pub last_mouse_btn: bool,
    pub last_click_ms: u64,
    pub wants_power_menu: bool,
    pub core_loads: [u32; 4],
    pub last_core_update_ticks: usize,
    pub dhcp_status: String,
}

impl SystemMonitorPane {
    pub fn new(x: i32, y: i32, w: u32, h: u32) -> Self {
        Self {
            x,
            y,
            width: w,
            height: h,
            last_update_ticks: 0,
            sort_col: SortColumn::Name,
            sort_asc: true,
            selected_idx: None,
            focused: false,
            last_mouse_btn: false,
            last_click_ms: 0,
            wants_power_menu: false,
            core_loads: [0; 4],
            last_core_update_ticks: 0,
            dhcp_status: String::new(),
        }
    }

    /// システムモニターペインのプレミアムな描画処理 (チラつき防止のため右側領域に部分限定描画)
    pub fn draw(&mut self, screen: &Screen) {
        let ux0 = self.x.max(0) as u32;
        let uy0 = self.y.max(0) as u32;
        let ux1 = (self.x + self.width as i32).max(0) as u32;
        let uy1 = (self.y + self.height as i32).max(0) as u32;
        let theme = crate::kernel::config::get_config().theme;

        // 1. 右側ペイン背景のクリア
        screen.boxfill(ux0, uy0, ux1, uy1, Color(theme.sysmon_bg));

        // ドットの背景装飾 (プレミアム感の向上)
        let dot_color = Color(theme.sysmon_header_bg);
        for gy in (uy0..uy1).step_by(30) {
            for gx in (ux0..ux1).step_by(30) {
                screen.draw_pixel(gx, gy, dot_color);
            }
        }

        // 装飾ヘッダ
        screen.boxfill(ux0, uy0, ux1, uy0 + 30, Color(theme.sysmon_header_bg));
        screen.boxfill(ux0, uy0 + 30, ux1, uy0 + 31, Color(theme.sysmon_accent)); // アクセントライン
        screen.draw_string_ja_size(
            ux0 + 15,
            uy0 + 8,
            "SYSTEM STATS MONITOR",
            14,
            Color(theme.sysmon_accent),
        );

        // Power ボタン (右上) - Fluent UI System Icons (MIT)
        static ICON_POWER: &[u8] = include_bytes!("../../icons/ic_fluent_power_20_regular.svg");
        let pwr_x = ux1.saturating_sub(45);
        let pwr_y = uy0 + 5;
        screen.boxfill(pwr_x, pwr_y, pwr_x + 35, pwr_y + 20, Color(theme.focus_highlight)); // 電源ボタン背景
        screen.draw_svg_icon(pwr_x + 8, pwr_y + 1, ICON_POWER, 18, Color(crate::kernel::config::get_config().theme.mouse_cursor));

        // 2. 統計情報の描画
        let text_color = Color(theme.sysmon_text);
        let val_color = Color(theme.sysmon_value);

        // 基本情報 (Uptimeは非表示)
        screen.draw_string_ja_size(ux0 + 15, uy0 + 45, "OS Kernel  :", 14, text_color);
        screen.draw_string_ja_size(ux0 + 120, uy0 + 45, "AtmOS v3 (SMP)", 14, val_color);
        screen.draw_string_ja_size(ux0 + 15, uy0 + 63, "CPU Cores  :", 14, text_color);
        screen.draw_string_ja_size(ux0 + 120, uy0 + 63, "4 Cores (SMP)", 14, val_color);

        let uptime_ticks = timer::get_ticks();

        // 3. ネットワーク情報 (接続時は Backend, MAC, IP のみ、未接続時はその旨を表示)
        screen.boxfill(ux0 + 10, uy0 + 82, ux1 - 10, uy0 + 83, Color(theme.sysmon_border));
        screen.draw_string_ja_size(
            ux0 + 15,
            uy0 + 95,
            "--- Network Interface ---",
            14,
            Color(theme.sysmon_accent),
        );

        let net_info = {
            let _lock = crate::kernel::net::NET_LOCK.lock();
            let st = crate::kernel::net::status();
            if st.link_up {
                let backend = crate::kernel::net::nic_backend_name(st.nic_backend);
                let mac_str = format!(
                    "{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
                    st.mac[0], st.mac[1], st.mac[2], st.mac[3], st.mac[4], st.mac[5]
                );
                let ip_str = format!("{}.{}.{}.{}", st.ip[0], st.ip[1], st.ip[2], st.ip[3]);
                Some((backend, mac_str, ip_str))
            } else {
                None
            }
        };

        if let Some((backend, mac, ip)) = net_info {
            let backend_line = format!("Backend : {}", backend);
            let mac_line = format!("MAC     : {}", mac);
            let ip_line = format!("IP      : {}", ip);
            screen.draw_string_ja_size(ux0 + 15, uy0 + 115, &backend_line, 14, Color(theme.sysmon_accent));
            screen.draw_string_ja_size(ux0 + 15, uy0 + 131, &mac_line, 14, Color(theme.sysmon_accent));
            screen.draw_string_ja_size(ux0 + 15, uy0 + 147, &ip_line, 14, Color(theme.sysmon_accent));
        } else {
            // DHCP ステータスを取得して表示。IP が未取得の場合はここに来る。
            let dhcp_status = crate::kernel::net::dhcp_status_line();
            screen.draw_string_ja_size(ux0 + 15, uy0 + 115, &dhcp_status, 14, Color(theme.focus_highlight));
            screen.draw_string_ja_size(ux0 + 15, uy0 + 131, "MAC     : -", 14, text_color);
            screen.draw_string_ja_size(ux0 + 15, uy0 + 147, "IP      : -", 14, text_color);
        }

        // 4. メモリ使用状況
        let mem_y0 = uy0 + 165;
        let (used, total) = crate::kernel::allocator::get_heap_stats();
        let used_mb = used as f32 / (1024.0 * 1024.0);
        let total_mb = total as f32 / (1024.0 * 1024.0);
        let usage_pct = if total > 0 {
            (used as f32 / total as f32) * 100.0
        } else {
            0.0
        };

        screen.boxfill(ux0 + 10, mem_y0, ux1 - 10, mem_y0 + 1, Color(theme.sysmon_border));
        screen.draw_string_ja_size(
            ux0 + 15,
            mem_y0 + 15,
            "--- Memory Heap ---",
            14,
            Color(theme.sysmon_accent),
        );

        let size_str = format!("{:.2} MB / {:.2} MB", used_mb, total_mb);
        screen.draw_string_ja_size(ux0 + 15, mem_y0 + 37, "Usage Info :", 14, text_color);
        screen.draw_string_ja_size(ux0 + 120, mem_y0 + 37, &size_str, 14, val_color);

        // 使用率インジケーター（メーター）の高さを拡張 (上下の潰れを解消)
        let bar_x0 = ux0 + 15;
        let bar_y0 = mem_y0 + 55;
        let bar_x1 = ux1 - 15;
        let bar_y1 = bar_y0 + 14; // 高さ14pxに変更
        let bar_w = bar_x1 - bar_x0;
        let fill_w = (bar_w as f32 * (usage_pct / 100.0)) as u32;

        screen.boxfill(bar_x0, bar_y0, bar_x1, bar_y1, Color(theme.sysmon_header_bg)); // メーター背景
        let meter_color = if usage_pct > 50.0 {
            Color(theme.focus_highlight) // 警告
        } else {
            Color(theme.sysmon_accent) // 通常
        };
        screen.boxfill(bar_x0, bar_y0, bar_x0 + fill_w, bar_y1, meter_color);

        let pct_str = format!("{:.1}% used", usage_pct);
        screen.draw_string_ja_size(ux0 + 15, mem_y0 + 74, &pct_str, 14, meter_color);

        // 5. 各CPUコアロード表示
        let cpu_y0 = mem_y0 + 95;
        screen.boxfill(ux0 + 10, cpu_y0, ux1 - 10, cpu_y0 + 1, Color(theme.sysmon_border));
        screen.draw_string_ja_size(
            ux0 + 15,
            cpu_y0 + 15,
            "--- Core Activity ---",
            14,
            Color(theme.sysmon_accent),
        );

        if self.last_core_update_ticks == 0
            || uptime_ticks.saturating_sub(self.last_core_update_ticks) >= 1000
        {
            for core in 0..4 {
                let seed = uptime_ticks.wrapping_add(core * 31);
                let mut hash = seed ^ (seed >> 15);
                hash = hash.wrapping_mul(0x85ebca6b);
                hash ^= hash >> 13;
                hash = hash.wrapping_mul(0xc2b2ae35);
                hash ^= hash >> 16;
                self.core_loads[core] = 10 + (hash % 41) as u32; // 10% - 50%
            }
            self.last_core_update_ticks = uptime_ticks;
        }

        let meter_bg = Color(theme.sysmon_header_bg);
        let meter_fg = Color(theme.sysmon_accent);
        let max_bar_w = (ux1 - ux0).saturating_sub(180).min(150); // 画面幅に応じてメーターの最大幅を制限
        for core in 0..4 {
            let core_y = cpu_y0 + 35 + (core as u32 * 22); // 行の高さを 22px に詰める
            let label = format!("Core {}:", core);
            screen.draw_string_ja_size(ux0 + 15, core_y, &label, 14, text_color);

            let load_val = self.core_loads[core];

            let bar_x0 = ux0 + 75;
            let bar_y0 = core_y + 2;
            let bar_x1 = bar_x0 + max_bar_w;
            let bar_y1 = bar_y0 + 10;

            screen.boxfill(bar_x0, bar_y0, bar_x1, bar_y1, meter_bg);
            let fill_width = (load_val * max_bar_w) / 50;
            screen.boxfill(bar_x0, bar_y0, bar_x0 + fill_width, bar_y1, meter_fg);

            let load_str = format!("{}%", load_val * 2);
            screen.draw_string_ja_size(bar_x1 + 8, core_y, &load_str, 14, val_color);
        }

        self.last_update_ticks = uptime_ticks;

        // 6. プロセスリスト (タスクマネージャ) 領域 (開始位置を 395 に引き上げ)
        self.draw_process_list(screen, ux0, uy0 + 395, ux1, uy1);
    }

    fn draw_process_list(&self, screen: &Screen, ux0: u32, y_start: u32, ux1: u32, uy1: u32) {
        let theme = crate::kernel::config::get_config().theme;
        let text_color = Color(theme.sysmon_text);
        let header_bg = Color(theme.sysmon_header_bg);
        let list_bg = Color(theme.sysmon_bg);
        let selected_bg = Color(theme.sysmon_border);

        screen.boxfill(ux0 + 10, y_start, ux1 - 10, y_start + 1, Color(theme.sysmon_border));
        screen.draw_string_ja_size(
            ux0 + 15,
            y_start + 10,
            "--- Running Processes ---",
            14,
            Color(theme.sysmon_accent),
        );

        let table_y = y_start + 30;

        // ヘッダ描画
        screen.boxfill(ux0, table_y, ux1, table_y + 20, header_bg);

        // 列の座標（パーセンテージによる動的レイアウト）
        let pane_w = ux1 - ux0;
        let col_ws_x = ux0 + 8;
        let col_state_x = ux0 + 26;
        let col_name_x = ux0 + 48;
        let col_info_x = ux0 + (pane_w * 55 / 100); // 55%

        let get_sort_marker = |col| {
            if self.sort_col == col {
                if self.sort_asc {
                    " [^]"
                } else {
                    " [v]"
                }
            } else {
                ""
            }
        };

        screen.draw_string_ja_size(col_ws_x, table_y + 3, "W", 14, Color(theme.sysmon_value));
        screen.draw_string_ja_size(col_state_x, table_y + 3, "S", 14, Color(theme.sysmon_value));
        screen.draw_string_ja_size(
            col_name_x,
            table_y + 3,
            &format!("Name{}", get_sort_marker(SortColumn::Name)),
            14,
            Color(theme.sysmon_value),
        );
        screen.draw_string_ja_size(
            col_info_x,
            table_y + 3,
            &format!("Info{}", get_sort_marker(SortColumn::Info)),
            14,
            Color(theme.sysmon_value),
        );

        let processes = self.build_process_list();
        let mut row_y = table_y + 20;
        let row_h = 18;

        for (i, p) in processes.iter().enumerate() {
            if row_y + row_h > uy1 {
                break;
            }

            let bg = if Some(i) == self.selected_idx {
                selected_bg
            } else {
                list_bg
            };
            screen.boxfill(ux0, row_y, ux1, row_y + row_h, bg);

            let fg = if Some(i) == self.selected_idx {
                Color(crate::kernel::config::get_config().theme.mouse_cursor)
            } else {
                text_color
            };

            // WS列
            let ws_str = match p.workspace {
                Some(ws) => alloc::format!("{}", ws),
                None => alloc::string::String::from("-"),
            };
            screen.draw_string_ja_size(col_ws_x, row_y + 2, &ws_str, 14, fg);

            // State列
            screen.draw_string_ja_size(col_state_x, row_y + 2, p.state_char, 14, fg);

            let name_str = if p.is_child {
                p.display_name.clone()
            } else {
                format!("> {}", p.display_name)
            };
            screen.draw_string_ja_size(col_name_x, row_y + 2, &name_str, 14, fg);
            screen.draw_string_ja_size(col_info_x, row_y + 2, &p.original_name, 14, fg);

            row_y += row_h;
        }

        // フォーカス枠
        if self.focused {
            screen.boxfill(ux0, y_start, ux1, y_start + 1, Color(theme.sysmon_accent));
            screen.boxfill(ux0, uy1 - 1, ux1, uy1, Color(theme.sysmon_accent));
            screen.boxfill(ux0, y_start, ux0 + 1, uy1, Color(theme.sysmon_accent));
            screen.boxfill(ux1 - 1, y_start, ux1, uy1, Color(theme.sysmon_accent));
        }
    }

    pub fn build_process_list(&self) -> alloc::vec::Vec<ProcessInfo> {
        let wm = window_mgr::get_instance();

        struct AppGroup {
            name: String,
            cpu: u32,
            ram: u32,
            instances: alloc::vec::Vec<(Option<usize>, String, u32, u32)>,
        }

        let mut groups: alloc::vec::Vec<AppGroup> = alloc::vec::Vec::new();

        let term_cpu = 15;
        let term_ram = 10;
        groups.push(AppGroup {
            name: String::from("Terminal"),
            cpu: term_cpu,
            ram: term_ram,
            instances: alloc::vec![(None, String::from("System Shell"), term_cpu, term_ram)],
        });

        for (i, win) in wm.windows.iter().enumerate() {
            let name = win.app.name();
            let info = win.app.instance_info();

            let cpu = 5 + (i as u32 * 3) % 20;
            let ram = 20 + (i as u32 * 7) % 50;

            if let Some(g) = groups.iter_mut().find(|g| g.name == name) {
                g.cpu += cpu;
                g.ram += ram;
                g.instances.push((Some(i), info, cpu, ram));
            } else {
                groups.push(AppGroup {
                    name: String::from(name),
                    cpu,
                    ram,
                    instances: alloc::vec![(Some(i), info, cpu, ram)],
                });
            }
        }

        groups.sort_by(|a, b| {
            let cmp = match self.sort_col {
                SortColumn::Name => a.name.cmp(&b.name),
                SortColumn::Cpu => a.cpu.cmp(&b.cpu),
                SortColumn::Ram => a.ram.cmp(&b.ram),
                SortColumn::Info => core::cmp::Ordering::Equal,
            };
            if self.sort_asc {
                cmp
            } else {
                cmp.reverse()
            }
        });

        let mut flat = alloc::vec::Vec::new();
        for g in groups {
            if g.instances.len() == 1 {
                let inst = &g.instances[0];
                let display_info = if inst.1.is_empty() {
                    String::from("-")
                } else {
                    inst.1.clone()
                };

                let mut ws = None;
                let mut state = "N";
                if let Some(win_idx) = inst.0 {
                    let win = &wm.windows[win_idx];
                    ws = Some(win.workspace);
                    state = if win.is_minimized {
                        "m"
                    } else if win.is_fullscreen {
                        "F"
                    } else if win.x == 100 && win.y == 0 {
                        "M"
                    } else {
                        "N"
                    };
                } else if g.name == "Terminal" {
                    ws = Some(wm.active_workspace);
                    state = "N";
                }

                flat.push(ProcessInfo {
                    window_idx: inst.0,
                    display_name: g.name.clone(),
                    cpu: inst.2,
                    ram: inst.3,
                    is_child: false,
                    original_name: display_info,
                    workspace: ws,
                    state_char: state,
                });
            } else {
                flat.push(ProcessInfo {
                    window_idx: None,
                    display_name: g.name.clone(),
                    cpu: g.cpu,
                    ram: g.ram,
                    is_child: false,
                    original_name: format!("{} instances", g.instances.len()),
                    workspace: None,
                    state_char: "N",
                });

                for (idx, inst) in g.instances.into_iter().enumerate() {
                    let display = if inst.1.is_empty() {
                        format!("{}: {}", g.name, idx + 1)
                    } else {
                        inst.1.clone()
                    };

                    let mut ws = None;
                    let mut state = "N";
                    if let Some(win_idx) = inst.0 {
                        let win = &wm.windows[win_idx];
                        ws = Some(win.workspace);
                        state = if win.is_minimized {
                            "m"
                        } else if win.is_fullscreen {
                            "F"
                        } else if win.x == 100 && win.y == 0 {
                            "M"
                        } else {
                            "N"
                        };
                    }

                    flat.push(ProcessInfo {
                        window_idx: inst.0,
                        display_name: format!("  |- {}", display),
                        cpu: inst.2,
                        ram: inst.3,
                        is_child: true,
                        original_name: display,
                        workspace: ws,
                        state_char: state,
                    });
                }
            }
        }

        flat
    }

    pub fn handle_mouse(&mut self, mx: i32, my: i32, btn_left: bool) -> bool {
        let btn_just_pressed = btn_left && !self.last_mouse_btn;
        self.last_mouse_btn = btn_left;

        if mx < self.x || mx > self.x + self.width as i32 {
            if btn_just_pressed {
                self.focused = false;
            }
            return false;
        }

        if btn_just_pressed {
            self.focused = true;

            // PWRボタンの判定
            let pwr_x = self.x + self.width as i32 - 45;
            let pwr_y = self.y + 5;
            if mx >= pwr_x && mx <= pwr_x + 35 && my >= pwr_y && my <= pwr_y + 20 {
                self.wants_power_menu = true;
                return true;
            }

            let now = crate::kernel::timer::get_system_time_ms();
            let is_double_click = (now - self.last_click_ms) < 400;
            self.last_click_ms = now;

            let uy0 = self.y.max(0) as u32;
            let y_start = uy0 + 395;
            let table_y = y_start + 30;

            if my as u32 >= table_y && (my as u32) < table_y + 20 {
                let rel_x = mx - self.x;
                let pane_w = self.width as i32;
                let new_col = if rel_x < (pane_w * 55 / 100) {
                    SortColumn::Name
                } else {
                    SortColumn::Info
                };

                if self.sort_col == new_col {
                    self.sort_asc = !self.sort_asc;
                } else {
                    self.sort_col = new_col;
                    self.sort_asc = true;
                }
                return true;
            }

            let list_start_y = table_y + 20;
            if my as u32 >= list_start_y {
                let row = ((my as u32 - list_start_y) / 18) as usize;
                let procs = self.build_process_list();
                if row < procs.len() {
                    self.selected_idx = Some(row);
                    if is_double_click {
                        self.activate_selected();
                    }
                } else {
                    self.selected_idx = None;
                }
            }
        }
        true
    }

    pub fn handle_key(&mut self, keycode: u8, _ascii: Option<char>) -> bool {
        if !self.focused {
            return false;
        }
        let procs = self.build_process_list();
        if procs.is_empty() {
            return false;
        }

        let handled = match keycode {
            0x48 => {
                // Up
                if let Some(mut idx) = self.selected_idx {
                    idx = idx.saturating_sub(1);
                    self.selected_idx = Some(idx);
                } else {
                    self.selected_idx = Some(0);
                }
                true
            }
            0x50 => {
                // Down
                if let Some(mut idx) = self.selected_idx {
                    if idx + 1 < procs.len() {
                        idx += 1;
                    }
                    self.selected_idx = Some(idx);
                } else {
                    self.selected_idx = Some(0);
                }
                true
            }
            0x1C => {
                // Enter
                self.activate_selected();
                true
            }
            _ => false,
        };

        if handled {
            window_mgr::get_instance().dirty = true;
        }
        handled
    }

    fn activate_selected(&mut self) {
        if let Some(idx) = self.selected_idx {
            let procs = self.build_process_list();
            if idx < procs.len() {
                let p = &procs[idx];
                if let Some(win_idx) = p.window_idx {
                    let mut wm = window_mgr::get_instance();
                    wm.windows[win_idx].is_minimized = false;
                    wm.activate_window(win_idx);
                    self.focused = false;
                } else if p.display_name == "Terminal" || p.display_name == "> Terminal" {
                    let mut wm = window_mgr::get_instance();
                    wm.terminal_focused = true;
                    if let Some(ws) = p.workspace {
                        wm.active_workspace = ws;
                    }
                    self.focused = false;
                }
            }
        }
    }
}

pub struct ProcessInfo {
    pub window_idx: Option<usize>,
    pub display_name: String,
    pub cpu: u32,
    pub ram: u32,
    pub is_child: bool,
    pub original_name: String,
    pub workspace: Option<u8>,
    pub state_char: &'static str,
}