/*
    * main.cpp
    * ZenithOS Desktop Environment - window manager, compositor, and run loop
    * Copyright (c) 2026 Daniel Hammer
*/

#include "apps_common.hpp"
#include "wallpaper.hpp"

// ============================================================================
// Desktop Implementation
// ============================================================================

static const char* month_names[] = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};

void gui::desktop_init(DesktopState* ds) {
    ds->screen_w = ds->fb.width();
    ds->screen_h = ds->fb.height();

    // Immediately clear the screen to hide flanterm boot text
    ds->fb.clear(colors::DESKTOP_BG);
    ds->fb.flip();

    // Load TrueType fonts
    fonts::init();

    ds->window_count = 0;
    ds->focused_window = -1;
    ds->prev_buttons = 0;
    ds->app_menu_open = false;

    zenith::memset(&ds->mouse, 0, sizeof(Zenith::MouseState));
    zenith::set_mouse_bounds(ds->screen_w - 1, ds->screen_h - 1);

    // Load SVG icons — scalable (colorful) for app menu, symbolic for toolbar/panel
    Color defColor = colors::ICON_COLOR;
    ds->icon_terminal    = svg_load("0:/icons/utilities-terminal.svg",        20, 20, defColor);
    ds->icon_filemanager = svg_load("0:/icons/system-file-manager.svg",      20, 20, defColor);
    ds->icon_sysinfo     = svg_load("0:/icons/preferences-desktop-apps.svg", 20, 20, defColor);
    ds->icon_appmenu     = svg_load("0:/icons/view-app-grid-symbolic.svg",   20, 20, colors::PANEL_TEXT);
    ds->icon_folder      = svg_load("0:/icons/folder.svg",                   16, 16, defColor);
    ds->icon_file        = svg_load("0:/icons/text-x-generic.svg",           16, 16, defColor);
    ds->icon_computer    = svg_load("0:/icons/computer.svg",                 20, 20, defColor);
    ds->icon_network     = svg_load("0:/icons/network-wired-symbolic.svg",   16, 16, colors::PANEL_TEXT);
    ds->icon_calculator  = svg_load("0:/icons/accessories-calculator.svg",   20, 20, defColor);
    ds->icon_texteditor  = svg_load("0:/icons/accessories-text-editor.svg",  20, 20, defColor);
    ds->icon_go_up       = svg_load("0:/icons/go-up-symbolic.svg",           16, 16, defColor);
    ds->icon_go_back     = svg_load("0:/icons/go-previous-symbolic.svg",     16, 16, defColor);
    ds->icon_go_forward  = svg_load("0:/icons/go-next-symbolic.svg",         16, 16, defColor);
    ds->icon_save        = svg_load("0:/icons/document-save-symbolic.svg",   16, 16, defColor);
    ds->icon_home        = svg_load("0:/icons/user-home.svg",                16, 16, defColor);
    ds->icon_exec        = svg_load("0:/icons/utilities-terminal.svg",        16, 16, defColor);
    ds->icon_wikipedia   = svg_load("0:/icons/web-browser.svg",              20, 20, defColor);

    ds->icon_folder_lg = svg_load("0:/icons/folder.svg",                   48, 48, defColor);
    ds->icon_file_lg   = svg_load("0:/icons/text-x-generic.svg",           48, 48, defColor);
    ds->icon_exec_lg   = svg_load("0:/icons/utilities-terminal.svg",        48, 48, defColor);

    ds->icon_settings = svg_load("0:/icons/help-about.svg",     20, 20, defColor);
    ds->icon_reboot   = svg_load("0:/icons/system-reboot.svg", 20, 20, defColor);
    ds->icon_shutdown = svg_load("0:/icons/system-shutdown.svg", 20, 20, defColor);

    ds->icon_weather = svg_load("0:/icons/weather-widget.svg", 20, 20, defColor);

    ds->icon_doom     = svg_load("0:/icons/doom.svg", 20, 20, defColor);
    ds->icon_procmgr  = svg_load("0:/icons/system-monitor.svg", 20, 20, defColor);
    ds->icon_mandelbrot = svg_load("0:/icons/applications-science.svg", 20, 20, defColor);
    ds->icon_devexplorer = svg_load("0:/icons/hardware.svg", 20, 20, defColor);

    // Settings defaults
    ds->settings.bg_gradient = true;
    ds->settings.bg_image = false;
    ds->settings.bg_grad_top = Color::from_rgb(0xD0, 0xD8, 0xE8);
    ds->settings.bg_grad_bottom = Color::from_rgb(0xA0, 0xA8, 0xB8);
    ds->settings.bg_solid = Color::from_rgb(0xD0, 0xD8, 0xE8);
    ds->settings.bg_image_path[0] = '\0';
    ds->settings.bg_wallpaper = nullptr;
    ds->settings.bg_wallpaper_w = 0;
    ds->settings.bg_wallpaper_h = 0;
    ds->settings.panel_color = Color::from_rgb(0x10, 0x10, 0x10);
    ds->settings.accent_color = colors::ACCENT;
    ds->settings.show_shadows = true;
    ds->settings.clock_24h = true;
    ds->settings.ui_scale = 1;

    // Try to load default wallpaper
    wallpaper_load(&ds->settings, "0:/home/troy-olson-MhYIwOiyZpM-unsplash.jpg",
                   ds->screen_w, ds->screen_h);
    zenith::win_setscale(1);

    ds->ctx_menu_open = false;
    ds->ctx_menu_x = 0;
    ds->ctx_menu_y = 0;

    ds->net_popup_open = false;
    zenith::get_netcfg(&ds->cached_net_cfg);
    ds->net_cfg_last_poll = zenith::get_milliseconds();
    ds->net_icon_rect = {0, 0, 0, 0};

}

int gui::desktop_create_window(DesktopState* ds, const char* title, int x, int y, int w, int h) {
    if (ds->window_count >= MAX_WINDOWS) return -1;

    int idx = ds->window_count;
    Window* win = &ds->windows[idx];
    zenith::memset(win, 0, sizeof(Window));

    zenith::strncpy(win->title, title, MAX_TITLE_LEN);
    win->frame = {x, y, w, h};
    win->state = WIN_NORMAL;
    win->z_order = idx;
    win->focused = true;
    win->dirty = true;
    win->dragging = false;
    win->resizing = false;
    win->saved_frame = win->frame;

    // Allocate content buffer
    Rect cr = win->content_rect();
    win->content_w = cr.w;
    win->content_h = cr.h;
    int buf_size = cr.w * cr.h * 4;
    win->content = (uint32_t*)zenith::alloc(buf_size);
    zenith::memset(win->content, 0xFF, buf_size);

    win->on_draw = nullptr;
    win->on_mouse = nullptr;
    win->on_key = nullptr;
    win->on_close = nullptr;
    win->on_poll = nullptr;
    win->app_data = nullptr;
    win->external = false;
    win->ext_win_id = -1;

    // Unfocus previous window
    if (ds->focused_window >= 0 && ds->focused_window < ds->window_count) {
        ds->windows[ds->focused_window].focused = false;
    }
    ds->focused_window = idx;
    ds->window_count++;

    return idx;
}

void gui::desktop_close_window(DesktopState* ds, int idx) {
    if (idx < 0 || idx >= ds->window_count) return;

    Window* win = &ds->windows[idx];

    // For external windows, send a close event instead of freeing the buffer
    if (win->external) {
        Zenith::WinEvent ev;
        zenith::memset(&ev, 0, sizeof(ev));
        ev.type = 3; // close
        zenith::win_sendevent(win->ext_win_id, &ev);
    }

    if (win->on_close) win->on_close(win);

    // Free content buffer (skip for external windows — shared memory)
    if (win->content && !win->external) {
        zenith::free(win->content);
        win->content = nullptr;
    }

    // Shift remaining windows down
    for (int i = idx; i < ds->window_count - 1; i++) {
        ds->windows[i] = ds->windows[i + 1];
    }
    ds->window_count--;

    // Fix focused window index
    if (ds->focused_window == idx) {
        ds->focused_window = ds->window_count > 0 ? ds->window_count - 1 : -1;
    } else if (ds->focused_window > idx) {
        ds->focused_window--;
    }

    if (ds->focused_window >= 0 && ds->focused_window < ds->window_count) {
        ds->windows[ds->focused_window].focused = true;
    }
}

void gui::desktop_raise_window(DesktopState* ds, int idx) {
    if (idx < 0 || idx >= ds->window_count) return;
    if (idx == ds->window_count - 1) {
        // Already on top, just focus
        if (ds->focused_window >= 0 && ds->focused_window < ds->window_count)
            ds->windows[ds->focused_window].focused = false;
        ds->focused_window = idx;
        ds->windows[idx].focused = true;
        return;
    }

    // Unfocus current
    if (ds->focused_window >= 0 && ds->focused_window < ds->window_count) {
        ds->windows[ds->focused_window].focused = false;
    }

    // Move window to end (top of stack)
    Window tmp = ds->windows[idx];
    for (int i = idx; i < ds->window_count - 1; i++) {
        ds->windows[i] = ds->windows[i + 1];
    }
    ds->windows[ds->window_count - 1] = tmp;

    ds->focused_window = ds->window_count - 1;
    ds->windows[ds->focused_window].focused = true;
}

void gui::desktop_draw_window(DesktopState* ds, int idx) {
    if (idx < 0 || idx >= ds->window_count) return;
    Window* win = &ds->windows[idx];
    if (win->state == WIN_MINIMIZED || win->state == WIN_CLOSED) return;

    Framebuffer& fb = ds->fb;
    int x = win->frame.x;
    int y = win->frame.y;
    int w = win->frame.w;
    int h = win->frame.h;

    // Draw shadow
    if (ds->settings.show_shadows)
        draw_shadow(fb, x, y, w, h, SHADOW_SIZE, colors::SHADOW);

    // Draw window body
    fb.fill_rect(x, y, w, h, colors::WINDOW_BG);

    // Draw titlebar
    Color tb_bg = win->focused ? colors::TITLEBAR_BG : Color::from_rgb(0xE8, 0xE8, 0xE8);
    fb.fill_rect(x, y, w, TITLEBAR_HEIGHT, tb_bg);

    // Draw border
    draw_rect(fb, x, y, w, h, colors::BORDER);
    // Titlebar bottom separator
    draw_hline(fb, x, y + TITLEBAR_HEIGHT - 1, w, colors::BORDER);

    // Draw window buttons (macOS style: close, minimize, maximize)
    Rect close_r = win->close_btn_rect();
    Rect min_r = win->min_btn_rect();
    Rect max_r = win->max_btn_rect();

    fill_circle(fb, close_r.x + BTN_RADIUS, close_r.y + BTN_RADIUS, BTN_RADIUS, colors::CLOSE_BTN);
    fill_circle(fb, min_r.x + BTN_RADIUS, min_r.y + BTN_RADIUS, BTN_RADIUS, colors::MIN_BTN);
    fill_circle(fb, max_r.x + BTN_RADIUS, max_r.y + BTN_RADIUS, BTN_RADIUS, colors::MAX_BTN);

    // Draw title text centered in titlebar (after buttons)
    int title_x = x + 12 + 44 + BTN_RADIUS * 2 + 12; // after buttons
    int title_y = y + (TITLEBAR_HEIGHT - system_font_height()) / 2;
    int title_w = text_width(win->title);
    // Center in remaining space
    int remaining_w = w - (title_x - x) - 12;
    if (remaining_w > title_w) {
        title_x += (remaining_w - title_w) / 2;
    }
    draw_text(fb, title_x, title_y, win->title, colors::TEXT_COLOR);

    // Call app draw callback to render content (skip during resize — buffer is old size)
    if (win->on_draw && !win->resizing) {
        win->on_draw(win, fb);
    }

    // Blit content buffer to framebuffer (clip to actual buffer size during resize)
    Rect cr = win->content_rect();
    if (win->content) {
        if (win->external && (cr.w != win->content_w || cr.h != win->content_h)) {
            // Nearest-neighbor scale for external windows (fixed-size shared buffer)
            int src_w = win->content_w;
            int src_h = win->content_h;
            int dst_w = cr.w;
            int dst_h = cr.h;
            uint32_t* buf = fb.buffer();
            int pitch = fb.pitch();
            for (int y = 0; y < dst_h; y++) {
                int dy = cr.y + y;
                if (dy < 0 || dy >= fb.height()) continue;
                int sy = y * src_h / dst_h;
                uint32_t* dst_row = (uint32_t*)((uint8_t*)buf + dy * pitch);
                uint32_t* src_row = win->content + sy * src_w;
                for (int x = 0; x < dst_w; x++) {
                    int dx = cr.x + x;
                    if (dx < 0 || dx >= fb.width()) continue;
                    dst_row[dx] = src_row[x * src_w / dst_w];
                }
            }
        } else {
            int blit_w = cr.w < win->content_w ? cr.w : win->content_w;
            int blit_h = cr.h < win->content_h ? cr.h : win->content_h;
            fb.blit(cr.x, cr.y, blit_w, blit_h, win->content);
        }
    }
}

void gui::desktop_draw_panel(DesktopState* ds) {
    Framebuffer& fb = ds->fb;
    int sw = ds->screen_w;

    // Panel gradient background (slightly lighter at top)
    Color pc = ds->settings.panel_color;
    for (int y = 0; y < PANEL_HEIGHT; y++) {
        int t = y * 255 / PANEL_HEIGHT;
        uint8_t r = pc.r + (10 - t * 10 / 255);
        uint8_t g = pc.g + (10 - t * 10 / 255);
        uint8_t b = pc.b + (10 - t * 10 / 255);
        fb.fill_rect(0, y, sw, 1, Color::from_rgb(r, g, b));
    }

    // Bottom highlight line (skip when wallpaper is set — the white bleeds through)
    if (!ds->settings.bg_image) {
        fb.fill_rect(0, PANEL_HEIGHT - 1, sw, 1, Color::from_rgba(0xFF, 0xFF, 0xFF, 0x10));
    }

    // App menu button (left side)
    int btn_x = 4;
    int btn_y = 2;
    int btn_w = 28;
    int btn_h = 28;

    if (ds->icon_appmenu.pixels) {
        int ix = btn_x + (btn_w - ds->icon_appmenu.width) / 2;
        int iy = btn_y + (btn_h - ds->icon_appmenu.height) / 2;
        fb.blit_alpha(ix, iy, ds->icon_appmenu.width, ds->icon_appmenu.height, ds->icon_appmenu.pixels);
    } else {
        for (int gr = 0; gr < 3; gr++) {
            for (int gc = 0; gc < 3; gc++) {
                int dx = btn_x + 6 + gc * 6;
                int dy = btn_y + 6 + gr * 6;
                fb.fill_rect(dx, dy, 3, 3, colors::PANEL_TEXT);
            }
        }
    }

    // Window indicator pills (center area)
    int indicator_x = 40;
    for (int i = 0; i < ds->window_count; i++) {
        Window* win = &ds->windows[i];
        if (win->state == WIN_CLOSED) continue;

        int tw = text_width(win->title);
        int pad = 12;
        int iw = tw + pad * 2;
        if (iw > 150) iw = 150;

        // Pre-blended indicator pill colors (opaque, blended against PANEL_BG)
        Color pill_bg = (i == ds->focused_window)
            ? colors::PANEL_INDICATOR_ACTIVE
            : colors::PANEL_INDICATOR_INACTIVE;

        fill_rounded_rect(fb, indicator_x, 4, iw, 24, 6, pill_bg);

        // Active window accent underline bar
        if (i == ds->focused_window) {
            fb.fill_rect(indicator_x + 4, 26, iw - 8, 2, ds->settings.accent_color);
        }

        // Truncate title if too long
        char short_title[20];
        zenith::strncpy(short_title, win->title, 18);

        int tx = indicator_x + pad;
        int ty = 4 + (24 - system_font_height()) / 2;
        draw_text(fb, tx, ty, short_title, colors::PANEL_TEXT);

        indicator_x += iw + 4;
    }

    // Date + Clock (right side)
    Zenith::DateTime dt;
    zenith::gettime(&dt);

    char clock_str[12];
    if (ds->settings.clock_24h) {
        snprintf(clock_str, sizeof(clock_str), "%02d:%02d", (int)dt.Hour, (int)dt.Minute);
    } else {
        int h12 = (int)dt.Hour % 12;
        if (h12 == 0) h12 = 12;
        const char* ampm = dt.Hour < 12 ? "AM" : "PM";
        snprintf(clock_str, sizeof(clock_str), "%d:%02d %s", h12, (int)dt.Minute, ampm);
    }
    int clock_w = text_width(clock_str);
    int clock_x = sw - clock_w - 12;
    int clock_y = (PANEL_HEIGHT - system_font_height()) / 2;
    draw_text(fb, clock_x, clock_y, clock_str, colors::PANEL_TEXT);

    // Date before clock
    char date_str[12];
    int month_idx = dt.Month > 0 && dt.Month <= 12 ? dt.Month - 1 : 0;
    snprintf(date_str, sizeof(date_str), "%s %d", month_names[month_idx], (int)dt.Day);
    int date_w = text_width(date_str);
    int date_x = clock_x - date_w - 10;
    draw_text(fb, date_x, clock_y, date_str, colors::PANEL_TEXT);

    // Network icon (to the left of the date)
    uint64_t now = zenith::get_milliseconds();
    if (now - ds->net_cfg_last_poll > 5000) {
        zenith::get_netcfg(&ds->cached_net_cfg);
        ds->net_cfg_last_poll = now;
    }

    int net_icon_x = date_x - 16 - 12;
    int net_icon_y = (PANEL_HEIGHT - 16) / 2;
    ds->net_icon_rect = {net_icon_x, net_icon_y, 16, 16};

    if (ds->icon_network.pixels) {
        if (ds->cached_net_cfg.ipAddress == 0) {
            uint32_t* src = ds->icon_network.pixels;
            int npx = 16 * 16;
            uint32_t tinted[256];
            for (int p = 0; p < npx; p++) {
                uint32_t px = src[p];
                uint8_t a = (px >> 24) & 0xFF;
                tinted[p] = ((uint32_t)a << 24) | 0x004444CC;
            }
            fb.blit_alpha(net_icon_x, net_icon_y, 16, 16, tinted);
        } else {
            fb.blit_alpha(net_icon_x, net_icon_y, ds->icon_network.width, ds->icon_network.height, ds->icon_network.pixels);
        }
    }
}

// ============================================================================
// App Menu (categorized)
// ============================================================================

static constexpr int MENU_W = 220;
static constexpr int MENU_ITEM_H = 36;
static constexpr int MENU_CAT_H = 28;
static constexpr int MENU_DIV_H = 10;

struct MenuRow {
    bool is_category;
    const char* label;    // "" for divider-only rows
    int app_id;           // -1 for category headers / dividers
};

static constexpr int MENU_ROW_COUNT = 20;
static const MenuRow menu_rows[MENU_ROW_COUNT] = {
    { true,  "Applications", -1 },
    { false, "Terminal",      0 },
    { false, "Files",         1 },
    { false, "Text Editor",   4 },
    { false, "Calculator",    3 },
    { true,  "Internet",     -1 },
    { false, "Wikipedia",     9 },
    { false, "Weather",      13 },
    { true,  "System",       -1 },
    { false, "System Info",   2 },
    { false, "Kernel Log",    5 },
    { false, "Processes",     6 },
    { false, "Devices",       8 },
    { true,  "Games",        -1 },
    { false, "Mandelbrot",    7 },
    { false, "DOOM",         10 },
    { true,  "",             -1 },  // divider
    { false, "Settings",     11 },
    { false, "Reboot",       12 },
    { false, "Shutdown",     14 },
};

static int menu_row_height(const MenuRow& row) {
    if (!row.is_category) return MENU_ITEM_H;
    return row.label[0] ? MENU_CAT_H : MENU_DIV_H;
}

static int menu_total_height() {
    int h = 10; // top + bottom padding
    for (int i = 0; i < MENU_ROW_COUNT; i++)
        h += menu_row_height(menu_rows[i]);
    return h;
}

static void desktop_draw_app_menu(DesktopState* ds) {
    Framebuffer& fb = ds->fb;

    int menu_x = 4;
    int menu_y = PANEL_HEIGHT + 2;
    int menu_h = menu_total_height();

    // Menu shadow
    draw_shadow(fb, menu_x, menu_y, MENU_W, menu_h, 4, colors::SHADOW);

    // Menu background with rounded corners
    fill_rounded_rect(fb, menu_x, menu_y, MENU_W, menu_h, 8, colors::MENU_BG);
    draw_rect(fb, menu_x, menu_y, MENU_W, menu_h, colors::BORDER);

    // Icon lookup by app_id
    SvgIcon* icons[15] = {
        &ds->icon_terminal,     // 0
        &ds->icon_filemanager,  // 1
        &ds->icon_sysinfo,      // 2
        &ds->icon_calculator,   // 3
        &ds->icon_texteditor,   // 4
        &ds->icon_terminal,     // 5 (Kernel Log)
        &ds->icon_procmgr,      // 6
        &ds->icon_mandelbrot,   // 7
        &ds->icon_devexplorer,  // 8
        &ds->icon_wikipedia,    // 9
        &ds->icon_doom,         // 10
        &ds->icon_settings,     // 11
        &ds->icon_reboot,       // 12
        &ds->icon_weather,      // 13
        &ds->icon_shutdown,     // 14
    };

    int mx = ds->mouse.x;
    int my = ds->mouse.y;
    int iy = menu_y + 5;

    for (int i = 0; i < MENU_ROW_COUNT; i++) {
        const MenuRow& row = menu_rows[i];
        int row_h = menu_row_height(row);

        if (row.is_category) {
            // Separator line above (except first category)
            if (i > 0) {
                for (int sx = menu_x + 8; sx < menu_x + MENU_W - 8; sx++)
                    fb.put_pixel(sx, iy + row_h / 2, colors::BORDER);
            }

            // Category label (dimmed), skip for divider-only rows
            if (row.label[0]) {
                int tx = menu_x + 12;
                int ty = iy + (row_h - system_font_height()) / 2;
                if (i > 0) ty += 2;
                draw_text(fb, tx, ty, row.label, Color::from_rgb(0x88, 0x88, 0x88));
            }
        } else {
            Rect item_rect = {menu_x + 4, iy, MENU_W - 8, row_h};

            // Hover highlight
            if (item_rect.contains(mx, my)) {
                fill_rounded_rect(fb, item_rect.x, item_rect.y, item_rect.w, item_rect.h, 4, colors::MENU_HOVER);
            }

            // Icon
            int icon_x = item_rect.x + 8;
            int icon_y = item_rect.y + (row_h - 20) / 2;
            if (row.app_id >= 0 && row.app_id < 15) {
                SvgIcon* icon = icons[row.app_id];
                if (icon && icon->pixels) {
                    fb.blit_alpha(icon_x, icon_y, icon->width, icon->height, icon->pixels);
                }
            }

            // Label
            int tx = icon_x + 28;
            int ty = item_rect.y + (row_h - system_font_height()) / 2;
            draw_text(fb, tx, ty, row.label, colors::TEXT_COLOR);
        }

        iy += row_h;
    }
}

static void desktop_draw_net_popup(DesktopState* ds) {
    Framebuffer& fb = ds->fb;

    int popup_w = 220;
    int popup_h = 130;
    int popup_x = ds->net_icon_rect.x + ds->net_icon_rect.w - popup_w;
    int popup_y = PANEL_HEIGHT + 2;
    if (popup_x < 4) popup_x = 4;

    draw_shadow(fb, popup_x, popup_y, popup_w, popup_h, 4, colors::SHADOW);
    fb.fill_rect(popup_x, popup_y, popup_w, popup_h, colors::MENU_BG);
    draw_rect(fb, popup_x, popup_y, popup_w, popup_h, colors::BORDER);

    int tx = popup_x + 12;
    int ty = popup_y + 10;
    int line_h = system_font_height() + 6;
    char line[64];

    Zenith::NetCfg& nc = ds->cached_net_cfg;

    if (nc.ipAddress != 0) {
        char ipbuf[20];
        format_ip(ipbuf, nc.ipAddress);
        snprintf(line, sizeof(line), "IP:      %s", ipbuf);
    } else {
        snprintf(line, sizeof(line), "IP:      Not connected");
    }
    draw_text(fb, tx, ty, line, colors::TEXT_COLOR);
    ty += line_h;

    char buf[20];
    format_ip(buf, nc.subnetMask);
    snprintf(line, sizeof(line), "Subnet:  %s", buf);
    draw_text(fb, tx, ty, line, colors::TEXT_COLOR);
    ty += line_h;

    format_ip(buf, nc.gateway);
    snprintf(line, sizeof(line), "Gateway: %s", buf);
    draw_text(fb, tx, ty, line, colors::TEXT_COLOR);
    ty += line_h;

    format_ip(buf, nc.dnsServer);
    snprintf(line, sizeof(line), "DNS:     %s", buf);
    draw_text(fb, tx, ty, line, colors::TEXT_COLOR);
    ty += line_h;

    format_mac(buf, nc.macAddress);
    snprintf(line, sizeof(line), "MAC:     %s", buf);
    draw_text(fb, tx, ty, line, colors::TEXT_COLOR);
}

// ============================================================================
// Reboot Dialog
// ============================================================================

struct RebootDialogState {
    DesktopState* ds;
    // Button layout (pixel-buffer-relative coordinates)
    int btn_w, btn_h, btn_y, reboot_x, cancel_x;
    bool hover_reboot, hover_cancel;
};

static void reboot_dialog_on_draw(Window* win, Framebuffer& fb) {
    RebootDialogState* rs = (RebootDialogState*)win->app_data;
    if (!rs) return;

    Canvas c(win);
    c.fill(colors::WINDOW_BG);

    // "Reboot the system?" centered
    const char* msg = "Reboot the system?";
    int tw = text_width(msg);
    c.text((c.w - tw) / 2, 30, msg, colors::TEXT_COLOR);

    // Compute button layout
    int btn_w = 100;
    int btn_h = 32;
    int btn_y = c.h - btn_h - 20;
    int gap = 20;
    int total_w = btn_w * 2 + gap;
    int bx = (c.w - total_w) / 2;
    rs->btn_w = btn_w;
    rs->btn_h = btn_h;
    rs->btn_y = btn_y;
    rs->reboot_x = bx;
    rs->cancel_x = bx + btn_w + gap;

    // Draw Reboot button
    Color reboot_bg = rs->hover_reboot
        ? Color::from_rgb(0xDD, 0x44, 0x44)
        : Color::from_rgb(0xCC, 0x33, 0x33);
    c.button(rs->reboot_x, btn_y, btn_w, btn_h, "Reboot", reboot_bg, colors::WHITE, 4);

    // Draw Cancel button
    Color cancel_bg = rs->hover_cancel
        ? Color::from_rgb(0x99, 0x99, 0x99)
        : Color::from_rgb(0x88, 0x88, 0x88);
    c.button(rs->cancel_x, btn_y, btn_w, btn_h, "Cancel", cancel_bg, colors::WHITE, 4);
}

static void reboot_dialog_on_mouse(Window* win, MouseEvent& ev) {
    RebootDialogState* rs = (RebootDialogState*)win->app_data;
    if (!rs) return;

    Rect cr = win->content_rect();
    int lx = ev.x - cr.x;
    int ly = ev.y - cr.y;

    Rect rb = {rs->reboot_x, rs->btn_y, rs->btn_w, rs->btn_h};
    Rect cb = {rs->cancel_x, rs->btn_y, rs->btn_w, rs->btn_h};
    rs->hover_reboot = rb.contains(lx, ly);
    rs->hover_cancel = cb.contains(lx, ly);

    if (ev.left_pressed()) {
        if (rs->hover_reboot) zenith::reset();
        if (rs->hover_cancel) {
            for (int i = 0; i < rs->ds->window_count; i++) {
                if (rs->ds->windows[i].app_data == rs) {
                    desktop_close_window(rs->ds, i);
                    return;
                }
            }
        }
    }
}

static void reboot_dialog_on_key(Window* win, const Zenith::KeyEvent& key) {
    RebootDialogState* rs = (RebootDialogState*)win->app_data;
    if (!rs || !key.pressed) return;

    if (key.ascii == '\n' || key.ascii == '\r') {
        zenith::reset();
    }
    if (key.scancode == 0x01) { // Escape
        for (int i = 0; i < rs->ds->window_count; i++) {
            if (rs->ds->windows[i].app_data == rs) {
                desktop_close_window(rs->ds, i);
                return;
            }
        }
    }
}

static void reboot_dialog_on_close(Window* win) {
    if (win->app_data) {
        zenith::mfree(win->app_data);
        win->app_data = nullptr;
    }
}

void open_reboot_dialog(DesktopState* ds) {
    int wx = (ds->screen_w - 300) / 2;
    int wy = (ds->screen_h - 150) / 2;
    int idx = desktop_create_window(ds, "Reboot", wx, wy, 300, 150);
    if (idx < 0) return;

    Window* win = &ds->windows[idx];
    RebootDialogState* rs = (RebootDialogState*)zenith::malloc(sizeof(RebootDialogState));
    zenith::memset(rs, 0, sizeof(RebootDialogState));
    rs->ds = ds;

    win->app_data = rs;
    win->on_draw = reboot_dialog_on_draw;
    win->on_mouse = reboot_dialog_on_mouse;
    win->on_key = reboot_dialog_on_key;
    win->on_close = reboot_dialog_on_close;
}

// ============================================================================
// Shutdown Dialog
// ============================================================================

struct ShutdownDialogState {
    DesktopState* ds;
    int btn_w, btn_h, btn_y, shutdown_x, cancel_x;
    bool hover_shutdown, hover_cancel;
};

static void shutdown_dialog_on_draw(Window* win, Framebuffer& fb) {
    ShutdownDialogState* ss = (ShutdownDialogState*)win->app_data;
    if (!ss) return;

    Canvas c(win);
    c.fill(colors::WINDOW_BG);

    const char* msg = "Shut down the system?";
    int tw = text_width(msg);
    c.text((c.w - tw) / 2, 30, msg, colors::TEXT_COLOR);

    int btn_w = 100;
    int btn_h = 32;
    int btn_y = c.h - btn_h - 20;
    int gap = 20;
    int total_w = btn_w * 2 + gap;
    int bx = (c.w - total_w) / 2;
    ss->btn_w = btn_w;
    ss->btn_h = btn_h;
    ss->btn_y = btn_y;
    ss->shutdown_x = bx;
    ss->cancel_x = bx + btn_w + gap;

    Color shutdown_bg = ss->hover_shutdown
        ? Color::from_rgb(0xDD, 0x44, 0x44)
        : Color::from_rgb(0xCC, 0x33, 0x33);
    c.button(ss->shutdown_x, btn_y, btn_w, btn_h, "Shut Down", shutdown_bg, colors::WHITE, 4);

    Color cancel_bg = ss->hover_cancel
        ? Color::from_rgb(0x99, 0x99, 0x99)
        : Color::from_rgb(0x88, 0x88, 0x88);
    c.button(ss->cancel_x, btn_y, btn_w, btn_h, "Cancel", cancel_bg, colors::WHITE, 4);
}

static void shutdown_dialog_on_mouse(Window* win, MouseEvent& ev) {
    ShutdownDialogState* ss = (ShutdownDialogState*)win->app_data;
    if (!ss) return;

    Rect cr = win->content_rect();
    int lx = ev.x - cr.x;
    int ly = ev.y - cr.y;

    Rect sb = {ss->shutdown_x, ss->btn_y, ss->btn_w, ss->btn_h};
    Rect cb = {ss->cancel_x, ss->btn_y, ss->btn_w, ss->btn_h};
    ss->hover_shutdown = sb.contains(lx, ly);
    ss->hover_cancel = cb.contains(lx, ly);

    if (ev.left_pressed()) {
        if (ss->hover_shutdown) zenith::shutdown();
        if (ss->hover_cancel) {
            for (int i = 0; i < ss->ds->window_count; i++) {
                if (ss->ds->windows[i].app_data == ss) {
                    desktop_close_window(ss->ds, i);
                    return;
                }
            }
        }
    }
}

static void shutdown_dialog_on_key(Window* win, const Zenith::KeyEvent& key) {
    ShutdownDialogState* ss = (ShutdownDialogState*)win->app_data;
    if (!ss || !key.pressed) return;

    if (key.ascii == '\n' || key.ascii == '\r') {
        zenith::shutdown();
    }
    if (key.scancode == 0x01) { // Escape
        for (int i = 0; i < ss->ds->window_count; i++) {
            if (ss->ds->windows[i].app_data == ss) {
                desktop_close_window(ss->ds, i);
                return;
            }
        }
    }
}

static void shutdown_dialog_on_close(Window* win) {
    if (win->app_data) {
        zenith::mfree(win->app_data);
        win->app_data = nullptr;
    }
}

void open_shutdown_dialog(DesktopState* ds) {
    int wx = (ds->screen_w - 300) / 2;
    int wy = (ds->screen_h - 150) / 2;
    int idx = desktop_create_window(ds, "Shut Down", wx, wy, 300, 150);
    if (idx < 0) return;

    Window* win = &ds->windows[idx];
    ShutdownDialogState* ss = (ShutdownDialogState*)zenith::malloc(sizeof(ShutdownDialogState));
    zenith::memset(ss, 0, sizeof(ShutdownDialogState));
    ss->ds = ds;

    win->app_data = ss;
    win->on_draw = shutdown_dialog_on_draw;
    win->on_mouse = shutdown_dialog_on_mouse;
    win->on_key = shutdown_dialog_on_key;
    win->on_close = shutdown_dialog_on_close;
}

static gui::ResizeEdge hit_test_resize_edge(const gui::Rect& f, int mx, int my) {
    using namespace gui;
    int G = RESIZE_GRAB;
    if (!f.contains(mx, my)) return RESIZE_NONE;

    bool near_left   = mx < f.x + G;
    bool near_right  = mx >= f.x + f.w - G;
    bool near_top    = my < f.y + G;
    bool near_bottom = my >= f.y + f.h - G;

    // Corners first
    if (near_top && near_left)     return RESIZE_TOP_LEFT;
    if (near_top && near_right)    return RESIZE_TOP_RIGHT;
    if (near_bottom && near_left)  return RESIZE_BOTTOM_LEFT;
    if (near_bottom && near_right) return RESIZE_BOTTOM_RIGHT;

    // Edges
    if (near_top)    return RESIZE_TOP;
    if (near_bottom) return RESIZE_BOTTOM;
    if (near_left)   return RESIZE_LEFT;
    if (near_right)  return RESIZE_RIGHT;

    return RESIZE_NONE;
}

static gui::CursorStyle cursor_for_edge(gui::ResizeEdge edge) {
    using namespace gui;
    switch (edge) {
    case RESIZE_LEFT: case RESIZE_RIGHT:
        return CURSOR_RESIZE_H;
    case RESIZE_TOP: case RESIZE_BOTTOM:
        return CURSOR_RESIZE_V;
    case RESIZE_TOP_LEFT: case RESIZE_BOTTOM_RIGHT:
        return CURSOR_RESIZE_NWSE;
    case RESIZE_TOP_RIGHT: case RESIZE_BOTTOM_LEFT:
        return CURSOR_RESIZE_NESW;
    default:
        return CURSOR_ARROW;
    }
}

void gui::desktop_compose(DesktopState* ds) {
    Framebuffer& fb = ds->fb;

    // Desktop background gradient
    int sw = ds->screen_w;
    int sh = ds->screen_h;
    int grad_start = PANEL_HEIGHT;
    int grad_range = sh - grad_start;
    if (grad_range < 1) grad_range = 1;

    uint32_t* buf = fb.buffer();
    int pitch = fb.pitch();

    for (int y = 0; y < sh; y++) {
        uint32_t* row = (uint32_t*)((uint8_t*)buf + y * pitch);
        if (ds->settings.bg_image && ds->settings.bg_wallpaper) {
            // Wallpaper covers the entire screen; panel draws on top
            uint32_t* wp = ds->settings.bg_wallpaper + y * ds->settings.bg_wallpaper_w;
            int cw = sw < ds->settings.bg_wallpaper_w ? sw : ds->settings.bg_wallpaper_w;
            for (int x = 0; x < cw; x++) row[x] = wp[x];
        } else if (y < grad_start) {
            // Panel area - will be overwritten by panel drawing
            uint32_t px = ds->settings.panel_color.to_pixel();
            for (int x = 0; x < sw; x++) row[x] = px;
        } else if (ds->settings.bg_gradient) {
            int t = y - grad_start;
            Color top = ds->settings.bg_grad_top;
            Color bot = ds->settings.bg_grad_bottom;
            uint8_t r = top.r - (top.r - bot.r) * t / grad_range;
            uint8_t g = top.g - (top.g - bot.g) * t / grad_range;
            uint8_t b = top.b - (top.b - bot.b) * t / grad_range;
            uint32_t px = 0xFF000000 | ((uint32_t)r << 16) | ((uint32_t)g << 8) | b;
            for (int x = 0; x < sw; x++) row[x] = px;
        } else {
            uint32_t px = ds->settings.bg_solid.to_pixel();
            for (int x = 0; x < sw; x++) row[x] = px;
        }
    }

    // Draw windows from bottom to top
    for (int i = 0; i < ds->window_count; i++) {
        if (ds->windows[i].state != WIN_MINIMIZED && ds->windows[i].state != WIN_CLOSED) {
            desktop_draw_window(ds, i);
        }
    }

    // Draw panel on top
    desktop_draw_panel(ds);

    // Draw app menu if open
    if (ds->app_menu_open) {
        desktop_draw_app_menu(ds);
    }

    // Draw network popup if open
    if (ds->net_popup_open) {
        desktop_draw_net_popup(ds);
    }

    // Draw right-click context menu if open
    if (ds->ctx_menu_open) {
        static constexpr int CTX_MENU_W = 180;
        static constexpr int CTX_ITEM_H = 36;
        static constexpr int CTX_ITEM_COUNT = 5;
        int cmx = ds->ctx_menu_x;
        int cmy = ds->ctx_menu_y;
        int cmh = CTX_ITEM_H * CTX_ITEM_COUNT + 8;

        // Clamp to screen
        if (cmx + CTX_MENU_W > sw) cmx = sw - CTX_MENU_W;
        if (cmy + cmh > sh) cmy = sh - cmh;

        draw_shadow(fb, cmx, cmy, CTX_MENU_W, cmh, 4, colors::SHADOW);
        fill_rounded_rect(fb, cmx, cmy, CTX_MENU_W, cmh, 8, colors::MENU_BG);
        draw_rect(fb, cmx, cmy, CTX_MENU_W, cmh, colors::BORDER);

        struct CtxItem { const char* label; SvgIcon* icon; };
        CtxItem ctx_items[CTX_ITEM_COUNT] = {
            { "Terminal", &ds->icon_terminal },
            { "Files",    &ds->icon_filemanager },
            { "About",    &ds->icon_settings },
            { "Reboot",   &ds->icon_reboot },
            { "Shutdown", &ds->icon_shutdown },
        };

        int mmx = ds->mouse.x;
        int mmy = ds->mouse.y;

        for (int i = 0; i < CTX_ITEM_COUNT; i++) {
            int iy = cmy + 4 + i * CTX_ITEM_H;
            Rect item_r = {cmx + 4, iy, CTX_MENU_W - 8, CTX_ITEM_H};

            if (item_r.contains(mmx, mmy)) {
                fill_rounded_rect(fb, item_r.x, item_r.y, item_r.w, item_r.h, 4, colors::MENU_HOVER);
            }

            int icon_x = item_r.x + 8;
            int icon_y = item_r.y + (CTX_ITEM_H - 20) / 2;
            if (ctx_items[i].icon && ctx_items[i].icon->pixels) {
                fb.blit_alpha(icon_x, icon_y, ctx_items[i].icon->width, ctx_items[i].icon->height, ctx_items[i].icon->pixels);
            }

            int tx = icon_x + 28;
            int ty = item_r.y + (CTX_ITEM_H - system_font_height()) / 2;
            draw_text(fb, tx, ty, ctx_items[i].label, colors::TEXT_COLOR);
        }
    }

    // Draw snap preview overlay while dragging to screen edge
    for (int i = 0; i < ds->window_count; i++) {
        Window* win = &ds->windows[i];
        if (win->dragging) {
            int dmx = ds->mouse.x;
            if (dmx <= 0) {
                fb.fill_rect_alpha(0, PANEL_HEIGHT, sw / 2, sh - PANEL_HEIGHT,
                    Color::from_rgba(0x33, 0x77, 0xCC, 0x30));
            } else if (dmx >= sw - 1) {
                fb.fill_rect_alpha(sw / 2, PANEL_HEIGHT, sw / 2, sh - PANEL_HEIGHT,
                    Color::from_rgba(0x33, 0x77, 0xCC, 0x30));
            }
            break;
        }
    }

    // Determine cursor style based on resize hover or active resize
    CursorStyle cur_style = CURSOR_ARROW;
    for (int i = ds->window_count - 1; i >= 0; i--) {
        Window* win = &ds->windows[i];
        if (win->resizing) {
            cur_style = cursor_for_edge(win->resize_edge);
            break;
        }
        if (win->state == WIN_MINIMIZED || win->state == WIN_CLOSED || win->state == WIN_MAXIMIZED)
            continue;
        if (win->frame.contains(ds->mouse.x, ds->mouse.y)) {
            ResizeEdge edge = hit_test_resize_edge(win->frame, ds->mouse.x, ds->mouse.y);
            if (edge != RESIZE_NONE) {
                cur_style = cursor_for_edge(edge);
            }
            break;
        }
    }

    // Draw cursor last
    draw_cursor(fb, ds->mouse.x, ds->mouse.y, cur_style);
}

void gui::desktop_handle_mouse(DesktopState* ds) {
    int mx = ds->mouse.x;
    int my = ds->mouse.y;
    uint8_t buttons = ds->mouse.buttons;
    uint8_t prev = ds->prev_buttons;
    bool left_pressed = (buttons & 0x01) && !(prev & 0x01);
    bool left_held = (buttons & 0x01);
    bool left_released = !(buttons & 0x01) && (prev & 0x01);
    bool right_pressed = (buttons & 0x02) && !(prev & 0x02);

    MouseEvent ev;
    ev.x = mx;
    ev.y = my;
    ev.buttons = buttons;
    ev.prev_buttons = prev;
    ev.scroll = ds->mouse.scrollDelta;

    // Handle context menu clicks
    if (ds->ctx_menu_open) {
        if (left_pressed) {
            static constexpr int CTX_MENU_W = 180;
            static constexpr int CTX_ITEM_H = 36;
            static constexpr int CTX_ITEM_COUNT = 5;
            int cmx = ds->ctx_menu_x;
            int cmy = ds->ctx_menu_y;
            int cmh = CTX_ITEM_H * CTX_ITEM_COUNT + 8;
            if (cmx + CTX_MENU_W > ds->screen_w) cmx = ds->screen_w - CTX_MENU_W;
            if (cmy + cmh > ds->screen_h) cmy = ds->screen_h - cmh;

            Rect ctx_rect = {cmx, cmy, CTX_MENU_W, cmh};
            if (ctx_rect.contains(mx, my)) {
                int rel_y = my - cmy - 4;
                int item_idx = rel_y / CTX_ITEM_H;
                if (item_idx >= 0 && item_idx < CTX_ITEM_COUNT) {
                    ds->ctx_menu_open = false;
                    switch (item_idx) {
                    case 0: open_terminal(ds); break;
                    case 1: open_filemanager(ds); break;
                    case 2: open_settings(ds); break;
                    case 3: open_reboot_dialog(ds); break;
                    case 4: open_shutdown_dialog(ds); break;
                    }
                    return;
                }
            }
            ds->ctx_menu_open = false;
            return;
        }
        if (right_pressed) {
            ds->ctx_menu_open = false;
            return;
        }
    }

    // Check for ongoing window drags first
    for (int i = 0; i < ds->window_count; i++) {
        Window* win = &ds->windows[i];
        if (win->dragging) {
            if (left_held) {
                win->frame.x = mx - win->drag_offset_x;
                win->frame.y = my - win->drag_offset_y;
                if (win->frame.x < -win->frame.w + 50) win->frame.x = -win->frame.w + 50;
                if (win->frame.y < 0) win->frame.y = 0;
                if (win->frame.x > ds->screen_w - 50) win->frame.x = ds->screen_w - 50;
                if (win->frame.y > ds->screen_h - 50) win->frame.y = ds->screen_h - 50;
            }
            if (left_released) {
                win->dragging = false;
                // Window edge snapping
                if (mx <= 0) {
                    win->saved_frame = win->frame;
                    win->frame = {0, PANEL_HEIGHT, ds->screen_w / 2, ds->screen_h - PANEL_HEIGHT};
                    win->state = WIN_MAXIMIZED;
                    if (!win->external) {
                        Rect cr = win->content_rect();
                        if (cr.w != win->content_w || cr.h != win->content_h) {
                            if (win->content) zenith::free(win->content);
                            win->content_w = cr.w;
                            win->content_h = cr.h;
                            win->content = (uint32_t*)zenith::alloc(cr.w * cr.h * 4);
                            zenith::memset(win->content, 0xFF, cr.w * cr.h * 4);
                        }
                    } else {
                        Rect cr = win->content_rect();
                        Zenith::WinEvent rev;
                        zenith::memset(&rev, 0, sizeof(rev));
                        rev.type = 2;
                        rev.resize.w = cr.w;
                        rev.resize.h = cr.h;
                        zenith::win_sendevent(win->ext_win_id, &rev);
                    }
                } else if (mx >= ds->screen_w - 1) {
                    win->saved_frame = win->frame;
                    win->frame = {ds->screen_w / 2, PANEL_HEIGHT, ds->screen_w / 2, ds->screen_h - PANEL_HEIGHT};
                    win->state = WIN_MAXIMIZED;
                    if (!win->external) {
                        Rect cr = win->content_rect();
                        if (cr.w != win->content_w || cr.h != win->content_h) {
                            if (win->content) zenith::free(win->content);
                            win->content_w = cr.w;
                            win->content_h = cr.h;
                            win->content = (uint32_t*)zenith::alloc(cr.w * cr.h * 4);
                            zenith::memset(win->content, 0xFF, cr.w * cr.h * 4);
                        }
                    } else {
                        Rect cr = win->content_rect();
                        Zenith::WinEvent rev;
                        zenith::memset(&rev, 0, sizeof(rev));
                        rev.type = 2;
                        rev.resize.w = cr.w;
                        rev.resize.h = cr.h;
                        zenith::win_sendevent(win->ext_win_id, &rev);
                    }
                }
            }
            return;
        }
    }

    // Check for ongoing window resizes
    for (int i = 0; i < ds->window_count; i++) {
        Window* win = &ds->windows[i];
        if (win->resizing) {
            if (left_held) {
                int dx = mx - win->resize_start_mx;
                int dy = my - win->resize_start_my;
                Rect sf = win->resize_start_frame;
                ResizeEdge edge = win->resize_edge;

                int new_x = sf.x, new_y = sf.y, new_w = sf.w, new_h = sf.h;

                if (edge == RESIZE_RIGHT || edge == RESIZE_TOP_RIGHT || edge == RESIZE_BOTTOM_RIGHT)
                    new_w = sf.w + dx;
                if (edge == RESIZE_BOTTOM || edge == RESIZE_BOTTOM_LEFT || edge == RESIZE_BOTTOM_RIGHT)
                    new_h = sf.h + dy;
                if (edge == RESIZE_LEFT || edge == RESIZE_TOP_LEFT || edge == RESIZE_BOTTOM_LEFT) {
                    new_x = sf.x + dx;
                    new_w = sf.w - dx;
                }
                if (edge == RESIZE_TOP || edge == RESIZE_TOP_LEFT || edge == RESIZE_TOP_RIGHT) {
                    new_y = sf.y + dy;
                    new_h = sf.h - dy;
                }

                // Enforce minimum size
                if (new_w < MIN_WINDOW_W) {
                    if (edge == RESIZE_LEFT || edge == RESIZE_TOP_LEFT || edge == RESIZE_BOTTOM_LEFT)
                        new_x = sf.x + sf.w - MIN_WINDOW_W;
                    new_w = MIN_WINDOW_W;
                }
                if (new_h < MIN_WINDOW_H) {
                    if (edge == RESIZE_TOP || edge == RESIZE_TOP_LEFT || edge == RESIZE_TOP_RIGHT)
                        new_y = sf.y + sf.h - MIN_WINDOW_H;
                    new_h = MIN_WINDOW_H;
                }

                win->frame = {new_x, new_y, new_w, new_h};
            }
            if (left_released) {
                win->resizing = false;
                // Reallocate content buffer if dimensions changed (skip for external)
                if (!win->external) {
                    Rect cr = win->content_rect();
                    if (cr.w != win->content_w || cr.h != win->content_h) {
                        if (win->content) zenith::free(win->content);
                        win->content_w = cr.w;
                        win->content_h = cr.h;
                        win->content = (uint32_t*)zenith::alloc(cr.w * cr.h * 4);
                        zenith::memset(win->content, 0xFF, cr.w * cr.h * 4);
                    }
                    win->dirty = true;
                } else {
                    Rect cr = win->content_rect();
                    Zenith::WinEvent rev;
                    zenith::memset(&rev, 0, sizeof(rev));
                    rev.type = 2;
                    rev.resize.w = cr.w;
                    rev.resize.h = cr.h;
                    zenith::win_sendevent(win->ext_win_id, &rev);
                }
            }
            return;
        }
    }

    // Handle app menu clicks
    if (ds->app_menu_open && left_pressed) {
        int menu_x = 4;
        int menu_y = PANEL_HEIGHT + 2;
        int menu_h = menu_total_height();
        Rect menu_rect = {menu_x, menu_y, MENU_W, menu_h};

        if (menu_rect.contains(mx, my)) {
            // Walk rows to find which one was clicked
            int iy = menu_y + 5;
            for (int i = 0; i < MENU_ROW_COUNT; i++) {
                const MenuRow& row = menu_rows[i];
                int row_h = menu_row_height(row);
                if (my >= iy && my < iy + row_h) {
                    if (!row.is_category) {
                        switch (row.app_id) {
                        case 0: open_terminal(ds); break;
                        case 1: open_filemanager(ds); break;
                        case 2: open_sysinfo(ds); break;
                        case 3: open_calculator(ds); break;
                        case 4: open_texteditor(ds); break;
                        case 5: open_klog(ds); break;
                        case 6: open_procmgr(ds); break;
                        case 7: open_mandelbrot(ds); break;
                        case 8: open_devexplorer(ds); break;
                        case 9: open_wiki(ds); break;
                        case 10: open_doom(ds); break;
                        case 11: open_settings(ds); break;
                        case 12: open_reboot_dialog(ds); break;
                        case 13: open_weather(ds); break;
                        case 14: open_shutdown_dialog(ds); break;
                        }
                        ds->app_menu_open = false;
                    }
                    break;
                }
                iy += row_h;
            }
            return;
        } else {
            ds->app_menu_open = false;
        }
    }

    // Handle net popup clicks
    if (ds->net_popup_open && left_pressed) {
        int popup_w = 220;
        int popup_h = 130;
        int popup_x = ds->net_icon_rect.x + ds->net_icon_rect.w - popup_w;
        int popup_y = PANEL_HEIGHT + 2;
        if (popup_x < 4) popup_x = 4;
        Rect popup_rect = {popup_x, popup_y, popup_w, popup_h};

        if (popup_rect.contains(mx, my)) {
            return;
        } else if (!ds->net_icon_rect.contains(mx, my)) {
            ds->net_popup_open = false;
        }
    }

    // Panel click check
    if (left_pressed && my < PANEL_HEIGHT) {
        // App menu button
        if (mx < 36) {
            ds->app_menu_open = !ds->app_menu_open;
            ds->net_popup_open = false;
            ds->ctx_menu_open = false;
            return;
        }

        // Network icon
        if (ds->net_icon_rect.w > 0 && ds->net_icon_rect.contains(mx, my)) {
            ds->net_popup_open = !ds->net_popup_open;
            ds->app_menu_open = false;
            ds->ctx_menu_open = false;
            return;
        }
        // Window indicator buttons
        int indicator_x = 40;
        for (int i = 0; i < ds->window_count; i++) {
            Window* win = &ds->windows[i];
            if (win->state == WIN_CLOSED) continue;

            int tw = text_width(win->title);
            int pad = 12;
            int iw = tw + pad * 2;
            if (iw > 150) iw = 150;

            Rect btn_rect = {indicator_x, 4, iw, 24};
            if (btn_rect.contains(mx, my)) {
                if (win->state == WIN_MINIMIZED) {
                    win->state = WIN_NORMAL;
                }
                desktop_raise_window(ds, i);
                return;
            }
            indicator_x += iw + 4;
        }
        return;
    }

    // Window interaction: check from top (last) to bottom (first)
    if (left_pressed) {
        for (int i = ds->window_count - 1; i >= 0; i--) {
            Window* win = &ds->windows[i];
            if (win->state == WIN_MINIMIZED || win->state == WIN_CLOSED) continue;

            // Check close button
            Rect close_r = win->close_btn_rect();
            if (close_r.contains(mx, my)) {
                desktop_close_window(ds, i);
                return;
            }

            // Check minimize button
            Rect min_r = win->min_btn_rect();
            if (min_r.contains(mx, my)) {
                win->state = WIN_MINIMIZED;
                if (ds->focused_window == i) {
                    ds->focused_window = -1;
                    for (int j = ds->window_count - 1; j >= 0; j--) {
                        if (ds->windows[j].state == WIN_NORMAL || ds->windows[j].state == WIN_MAXIMIZED) {
                            ds->focused_window = j;
                            ds->windows[j].focused = true;
                            break;
                        }
                    }
                }
                return;
            }

            // Check maximize button
            Rect max_r = win->max_btn_rect();
            if (max_r.contains(mx, my)) {
                if (win->state == WIN_MAXIMIZED) {
                    win->frame = win->saved_frame;
                    win->state = WIN_NORMAL;
                } else {
                    win->saved_frame = win->frame;
                    win->frame = {0, PANEL_HEIGHT, ds->screen_w, ds->screen_h - PANEL_HEIGHT};
                    win->state = WIN_MAXIMIZED;
                }
                // Reallocate content buffer for local windows only
                if (!win->external) {
                    Rect cr = win->content_rect();
                    if (cr.w != win->content_w || cr.h != win->content_h) {
                        if (win->content) zenith::free(win->content);
                        win->content_w = cr.w;
                        win->content_h = cr.h;
                        win->content = (uint32_t*)zenith::alloc(cr.w * cr.h * 4);
                        zenith::memset(win->content, 0xFF, cr.w * cr.h * 4);
                    }
                } else {
                    Rect cr = win->content_rect();
                    Zenith::WinEvent rev;
                    zenith::memset(&rev, 0, sizeof(rev));
                    rev.type = 2;
                    rev.resize.w = cr.w;
                    rev.resize.h = cr.h;
                    zenith::win_sendevent(win->ext_win_id, &rev);
                }
                desktop_raise_window(ds, i);
                return;
            }

            // Check resize edges (before titlebar drag, so corner grabs work)
            if (win->state != WIN_MAXIMIZED) {
                ResizeEdge edge = hit_test_resize_edge(win->frame, mx, my);
                if (edge != RESIZE_NONE) {
                    win->resizing = true;
                    win->resize_edge = edge;
                    win->resize_start_frame = win->frame;
                    win->resize_start_mx = mx;
                    win->resize_start_my = my;
                    desktop_raise_window(ds, i);
                    int new_idx = ds->window_count - 1;
                    ds->windows[new_idx].resizing = true;
                    ds->windows[new_idx].resize_edge = edge;
                    ds->windows[new_idx].resize_start_frame = ds->windows[new_idx].frame;
                    ds->windows[new_idx].resize_start_mx = mx;
                    ds->windows[new_idx].resize_start_my = my;
                    return;
                }
            }

            // Check titlebar (start drag)
            Rect tb = win->titlebar_rect();
            if (tb.contains(mx, my)) {
                win->dragging = true;
                win->drag_offset_x = mx - win->frame.x;
                win->drag_offset_y = my - win->frame.y;
                desktop_raise_window(ds, i);
                int new_idx = ds->window_count - 1;
                ds->windows[new_idx].dragging = true;
                ds->windows[new_idx].drag_offset_x = mx - ds->windows[new_idx].frame.x;
                ds->windows[new_idx].drag_offset_y = my - ds->windows[new_idx].frame.y;
                return;
            }

            // Check content area
            Rect cr = win->content_rect();
            if (cr.contains(mx, my)) {
                desktop_raise_window(ds, i);
                int new_idx = ds->window_count - 1;
                Window* raised = &ds->windows[new_idx];
                if (raised->external) {
                    // Forward mouse event to external window
                    Zenith::WinEvent wev;
                    zenith::memset(&wev, 0, sizeof(wev));
                    wev.type = 1; // mouse
                    wev.mouse.x = mx - cr.x;
                    wev.mouse.y = my - cr.y;
                    wev.mouse.scroll = ev.scroll;
                    wev.mouse.buttons = buttons;
                    wev.mouse.prev_buttons = prev;
                    zenith::win_sendevent(raised->ext_win_id, &wev);
                } else if (raised->on_mouse) {
                    ev.x = mx;
                    ev.y = my;
                    raised->on_mouse(raised, ev);
                }
                return;
            }

            // Check full frame
            if (win->frame.contains(mx, my)) {
                desktop_raise_window(ds, i);
                return;
            }
        }

        ds->app_menu_open = false;
        ds->ctx_menu_open = false;
    }

    // Handle scroll events on focused window
    if (ev.scroll != 0 && ds->focused_window >= 0) {
        Window* win = &ds->windows[ds->focused_window];
        Rect cr = win->content_rect();
        if (cr.contains(mx, my)) {
            if (win->external) {
                Zenith::WinEvent wev;
                zenith::memset(&wev, 0, sizeof(wev));
                wev.type = 1; // mouse
                wev.mouse.x = mx - cr.x;
                wev.mouse.y = my - cr.y;
                wev.mouse.scroll = ev.scroll;
                wev.mouse.buttons = buttons;
                wev.mouse.prev_buttons = prev;
                zenith::win_sendevent(win->ext_win_id, &wev);
            } else if (win->on_mouse) {
                win->on_mouse(win, ev);
            }
        }
    }

    // Right-click on desktop background opens context menu
    if (right_pressed && my >= PANEL_HEIGHT) {
        bool on_window = false;
        for (int i = ds->window_count - 1; i >= 0; i--) {
            Window* win = &ds->windows[i];
            if (win->state == WIN_MINIMIZED || win->state == WIN_CLOSED) continue;
            if (win->frame.contains(mx, my)) {
                on_window = true;
                break;
            }
        }
        if (!on_window) {
            ds->ctx_menu_open = true;
            ds->ctx_menu_x = mx;
            ds->ctx_menu_y = my;
            ds->app_menu_open = false;
            ds->net_popup_open = false;
        }
    }
}

void gui::desktop_handle_keyboard(DesktopState* ds, const Zenith::KeyEvent& key) {
    // Global shortcuts (only on key press)
    if (key.pressed && key.ctrl && key.alt) {
        if (key.ascii == 't' || key.ascii == 'T') {
            open_terminal(ds);
            return;
        }
        if (key.ascii == 'f' || key.ascii == 'F') {
            open_filemanager(ds);
            return;
        }
        if (key.ascii == 'i' || key.ascii == 'I') {
            open_sysinfo(ds);
            return;
        }
        if (key.ascii == 'c' || key.ascii == 'C') {
            open_calculator(ds);
            return;
        }
        if (key.ascii == 'e' || key.ascii == 'E') {
            open_texteditor(ds);
            return;
        }
        if (key.ascii == 'k' || key.ascii == 'K') {
            open_klog(ds);
            return;
        }
        if (key.ascii == 'd' || key.ascii == 'D') {
            open_doom(ds);
            return;
        }
    }

    // Dispatch to focused window
    if (ds->focused_window >= 0 && ds->focused_window < ds->window_count) {
        Window* win = &ds->windows[ds->focused_window];
        if (win->external) {
            // Forward key event to external window via syscall
            Zenith::WinEvent ev;
            zenith::memset(&ev, 0, sizeof(ev));
            ev.type = 0; // key
            ev.key = key;
            zenith::win_sendevent(win->ext_win_id, &ev);
        } else if (win->on_key) {
            win->on_key(win, key);
        }
    }
}

// ============================================================================
// External Window Polling
// ============================================================================

void desktop_poll_external_windows(DesktopState* ds) {
    Zenith::WinInfo extWins[8];
    int extCount = zenith::win_enumerate(extWins, 8);

    // Check for new external windows and map them
    for (int e = 0; e < extCount; e++) {
        int extId = extWins[e].id;

        // Check if we already have this window
        bool found = false;
        for (int i = 0; i < ds->window_count; i++) {
            if (ds->windows[i].external && ds->windows[i].ext_win_id == extId) {
                found = true;
                // Update dirty flag
                if (extWins[e].dirty) {
                    ds->windows[i].dirty = true;
                }
                // Re-map if external app resized its buffer
                if (extWins[e].width != ds->windows[i].content_w ||
                    extWins[e].height != ds->windows[i].content_h) {
                    uint64_t va = zenith::win_map(extId);
                    if (va != 0) {
                        ds->windows[i].content = (uint32_t*)va;
                        ds->windows[i].content_w = extWins[e].width;
                        ds->windows[i].content_h = extWins[e].height;
                        ds->windows[i].dirty = true;
                    }
                }
                break;
            }
        }

        if (!found && ds->window_count < MAX_WINDOWS) {
            // Map the pixel buffer into our address space
            uint64_t va = zenith::win_map(extId);
            if (va == 0) continue;

            int idx = ds->window_count;
            Window* win = &ds->windows[idx];
            zenith::memset(win, 0, sizeof(Window));

            zenith::strncpy(win->title, extWins[e].title, MAX_TITLE_LEN);
            int w = extWins[e].width;
            int h = extWins[e].height;
            // Position the window centered-ish
            int wx = (ds->screen_w - w - 2 * BORDER_WIDTH) / 2 + idx * 30;
            int wy = PANEL_HEIGHT + 20 + idx * 30;
            win->frame = {wx, wy, w + 2 * BORDER_WIDTH, h + TITLEBAR_HEIGHT + BORDER_WIDTH};
            win->state = WIN_NORMAL;
            win->z_order = idx;
            win->focused = true;
            win->dirty = true;
            win->dragging = false;
            win->resizing = false;
            win->saved_frame = win->frame;

            // Point content to the shared pixel buffer
            win->content = (uint32_t*)va;
            win->content_w = w;
            win->content_h = h;

            win->on_draw = nullptr;
            win->on_mouse = nullptr;
            win->on_key = nullptr;
            win->on_close = nullptr;
            win->on_poll = nullptr;
            win->app_data = nullptr;
            win->external = true;
            win->ext_win_id = extId;

            // Unfocus previous window
            if (ds->focused_window >= 0 && ds->focused_window < ds->window_count) {
                ds->windows[ds->focused_window].focused = false;
            }
            ds->focused_window = idx;
            ds->window_count++;
        }
    }

    // Check for removed external windows (process exited)
    for (int i = ds->window_count - 1; i >= 0; i--) {
        if (!ds->windows[i].external) continue;

        int extId = ds->windows[i].ext_win_id;
        bool stillExists = false;
        for (int e = 0; e < extCount; e++) {
            if (extWins[e].id == extId) {
                stillExists = true;
                break;
            }
        }

        if (!stillExists) {
            // Window gone — remove without freeing content (shared memory)
            ds->windows[i].content = nullptr; // prevent free
            gui::desktop_close_window(ds, i);
        }
    }
}

void gui::desktop_run(DesktopState* ds) {
    for (;;) {
        // Poll mouse state
        ds->prev_buttons = ds->mouse.buttons;
        zenith::mouse_state(&ds->mouse);

        // Poll keyboard events
        while (zenith::is_key_available()) {
            Zenith::KeyEvent key;
            zenith::getkey(&key);
            desktop_handle_keyboard(ds, key);
        }

        // Poll external windows (discover new, remove dead, update dirty)
        desktop_poll_external_windows(ds);

        // Poll windows that have a poll callback
        for (int i = 0; i < ds->window_count; i++) {
            Window* win = &ds->windows[i];
            if (win->state == WIN_CLOSED) continue;
            if (win->on_poll) {
                win->on_poll(win);
            }
        }

        // Handle mouse events
        desktop_handle_mouse(ds);

        // Compose and present
        desktop_compose(ds);
        ds->fb.flip();

        // Target ~60fps
        zenith::sleep_ms(16);
    }
}

// ============================================================================
// Entry Point
// ============================================================================

static DesktopState* g_desktop;

extern "C" void _start() {
    DesktopState* ds = (DesktopState*)zenith::malloc(sizeof(DesktopState));
    zenith::memset(ds, 0, sizeof(DesktopState));

    // Placement-new the Framebuffer since it has a constructor
    new (&ds->fb) Framebuffer();

    g_desktop = ds;

    desktop_init(ds);
    desktop_run(ds);

    zenith::exit(0);
}