/*
    * main.cpp
    * MontaukOS Settings: every settings page in one window, filed by
    * category and searchable by name, description and keywords. Pages are
    * catalog items (gui/app_catalog.hpp); opening one asks the desktop to
    * launch it.
    * Copyright (c) 2026 Daniel Hammer
*/

#include <montauk/syscall.h>
#include <montauk/string.h>
#include <montauk/heap.h>
#include <montauk/user.h>
#include <montauk/utf8.h>
#include <gui/mtk.hpp>
#include <gui/mtk/settings.hpp>
#include <gui/standalone.hpp>
#include <gui/app_catalog.hpp>
#include <gui/transfer.hpp>

extern "C" {
#include <stdio.h>
}

using namespace gui;

static constexpr int WIN_W        = 860;
static constexpr int WIN_H        = 580;
static constexpr int SIDEBAR_W    = 232;
static constexpr int SEARCH_H     = 32;
static constexpr int SEARCH_ICON_X = 9;    // magnifier inset
static constexpr int SEARCH_TEXT_X = 31;   // text inset, after the magnifier
static constexpr int SEARCH_RADIUS = 4;    // matches the sidebar rows
static constexpr int CLEAR_SIZE   = 16;
static constexpr int CAT_TOP      = 62;
static constexpr int CAT_ROW_H    = 34;
static constexpr int PAD          = 24;
static constexpr int HEADER_H     = 86;
static constexpr int GROUP_H      = 36;
static constexpr int TILE_H       = 68;
static constexpr int TILE_GAP     = 10;
static constexpr int TILE_MIN_W   = 280;
static constexpr int TILE_ICON    = 32;
static constexpr int TITLE_SIZE   = 24;
static constexpr int SCROLL_STEP  = 48;

static constexpr int MAX_ENTRIES    = 128;
static constexpr int MAX_CATEGORIES = 16;
static constexpr int MAX_PLACED     = MAX_ENTRIES + MAX_CATEGORIES;

static constexpr int CAT_ALL  = -1;
static constexpr int CAT_NONE = -2;

static constexpr Color SIDEBAR_BG    = Color::from_rgb(0xF6, 0xF6, 0xF6);
static constexpr Color SIDEBAR_HOVER = Color::from_rgb(0xEA, 0xEA, 0xEA);
static constexpr Color SYMBOLIC      = Color::from_rgb(0x5C, 0x61, 0x6C);
static constexpr Color SEARCH_BG     = Color::from_rgb(0xE6, 0xE6, 0xE6);
static constexpr Color SEARCH_HOVER  = Color::from_rgb(0xDF, 0xDF, 0xDF);
static constexpr Color CLEAR_BG      = Color::from_rgb(0xA8, 0xA8, 0xA8);
static constexpr Color CLEAR_HOVER   = Color::from_rgb(0x88, 0x88, 0x88);

// One settings page.
struct Entry {
    int item;        // index into g_ds->desktop_items
    int category;    // index into g_categories
    SvgIcon icon;    // TILE_ICON px
};

struct Category {
    char name[24];
    SvgIcon icon;    // 16 px symbolic
    int count;
};

// A laid-out group heading or tile. Rects are in content coordinates: x is
// window x, y is relative to the top of the scrolled pane (which starts with
// the title header, so tiles begin at HEADER_H).
enum PlacedKind : uint8_t { PLACED_HEADING, PLACED_TILE };
struct Placed {
    PlacedKind kind;
    int ref;         // category index (heading) or entry index (tile)
    Rect r;
};

static WsWindow g_win;
static DesktopState* g_ds = nullptr;
static Color g_accent = colors::ACCENT;

static Entry g_entries[MAX_ENTRIES];
static int g_entry_count = 0;
static Category g_categories[MAX_CATEGORIES];
static int g_category_count = 0;
static SvgIcon g_icon_all;
static SvgIcon g_icon_search;
static SvgIcon g_icon_clear;

// View
static int g_category = CAT_ALL;
static char g_query[64] = {};
static mtk::TextInputState g_search = {};
// Keyboard focus: the search field, the tiles (arrows move between them), or
// neither. Typing with neither focuses the search field.
static bool g_search_focus = false;
static bool g_grid_focus = false;
static int g_scroll = 0;
static int g_selected = -1;         // index into g_placed (a tile), keyboard focus
static int g_hover_tile = -1;       // index into g_placed
static int g_hover_cat = CAT_NONE;
static int g_mouse_x = -1;
static int g_mouse_y = -1;

static Placed g_placed[MAX_PLACED];
static int g_placed_count = 0;
static int g_content_h = 0;
static int g_result_count = 0;

static mtk::Theme app_theme() { return mtk::make_theme(g_accent); }

// ==== Text helpers ====

static char fold(char c) { return (c >= 'A' && c <= 'Z') ? c + 32 : c; }

// Case-insensitive (ASCII) search for needle[0..nlen) in haystack.
static int find_folded(const char* haystack, const char* needle, int nlen) {
    if (nlen <= 0) return 0;
    for (int i = 0; haystack[i]; i++) {
        int j = 0;
        while (j < nlen && haystack[i + j] && fold(haystack[i + j]) == fold(needle[j])) j++;
        if (j == nlen) return i;
    }
    return -1;
}

static bool is_word_start(const char* s, int i) {
    if (i == 0) return true;
    char p = s[i - 1];
    return p == ' ' || p == '-' || p == '&' || p == '/' || p == ',';
}

// src cut to fit max_w pixels, with a trailing "..." when cut.
static void fit_text(const char* src, char* out, int out_len, int max_w,
                     TrueTypeFont* font = nullptr, int size = 0) {
    auto width = [&](const char* s) {
        return font ? gui::text_width(font, s, size) : text_width(s);
    };
    montauk::strncpy(out, src ? src : "", out_len);
    if (out_len <= 4 || width(out) <= max_w) return;
    int ellipsis_w = width("...");
    int len = montauk::slen(out);
    while (len > 0) {
        out[len] = '\0';
        if (width(out) + ellipsis_w <= max_w) break;
        len = montauk::utf8::prev_boundary(out, len);
    }
    if (len > out_len - 4) len = montauk::utf8::floor_boundary(out, len, out_len - 4);
    if (len < 0) len = 0;
    montauk::strcpy(out + len, "...");
}

static void draw_bold(Canvas& c, int x, int y, const char* s, Color color, int size) {
    TrueTypeFont* font = fonts::system_bold ? fonts::system_bold : fonts::system_font;
    gui::draw_text(c, font, x, y, s, color, size);
}

// ==== Catalog ====

static const DesktopItem& entry_item(int e) { return g_ds->desktop_items[g_entries[e].item]; }

static const char* category_icon_path(const char* name) {
    struct { const char* name; const char* icon; } map[] = {
        { "Personalization",    "org.gnome.Settings-appearance-symbolic.svg" },
        { "Network",            "org.gnome.Settings-network-symbolic.svg" },
        { "Devices",            "computer-symbolic.svg" },
        { "Time & Language",    "preferences-system-time-symbolic.svg" },
        { "Accounts",           "system-users-symbolic.svg" },
        { "Privacy & Security", "security-high-symbolic.svg" },
        { "System",             "preferences-system-symbolic.svg" },
    };
    for (auto& m : map)
        if (montauk::streq(m.name, name)) return m.icon;
    return "applications-system-symbolic.svg";
}

static SvgIcon load_symbolic(const char* file) {
    char path[128];
    snprintf(path, sizeof(path), "0:/os/icons/%s", file);
    return svg_load(path, 16, 16, SYMBOLIC);
}

static int find_category(const char* name) {
    for (int i = 0; i < g_category_count; i++)
        if (app_catalog_compare_ci(g_categories[i].name, name) == 0) return i;
    return -1;
}

static int add_category(const char* name) {
    if (g_category_count >= MAX_CATEGORIES) return -1;
    Category& cat = g_categories[g_category_count];
    montauk::strncpy(cat.name, name, sizeof(cat.name));
    cat.count = 0;
    cat.icon = {};
    return g_category_count++;
}

static void load_identity() {
    char user[64] = {};
    if (montauk::getuser(user, sizeof(user)) <= 0 || !user[0]) montauk::strcpy(user, "default");
    montauk::strncpy(g_ds->current_user, user, sizeof(g_ds->current_user));

    // UI affordance only (admin_only pages); the kernel enforces what each
    // page may actually do, and the desktop refuses to launch them anyway.
    montauk::user::UserInfo users[16];
    int count = montauk::user::load_users(users, 16);
    for (int i = 0; i < count; i++) {
        if (montauk::streq(users[i].username, user)) {
            g_ds->is_admin = montauk::streq(users[i].role, "admin");
            break;
        }
    }
}

static void load_catalog() {
    app_catalog_add_builtin_pages(g_ds, 0);
    app_catalog_add_manifest_apps(g_ds);

    // The fixed categories first, in their display order; any others a
    // manifest names follow, by name.
    for (const char* name : kSettingsCategories) add_category(name);
    int fixed = g_category_count;

    for (int i = 0; i < g_ds->desktop_item_count && g_entry_count < MAX_ENTRIES; i++) {
        DesktopItem& item = g_ds->desktop_items[i];
        // The catalog loads small icons for every app; Settings draws its own.
        if (item.icon.pixels) svg_free(item.icon);
        if (!app_catalog_in_settings(item)) continue;
        if (item.admin_only && !g_ds->is_admin) continue;

        const char* cat_name = item.settings_category[0] ? item.settings_category
                                                         : kSettingsDefaultCategory;
        int cat = find_category(cat_name);
        if (cat < 0) cat = add_category(cat_name);
        if (cat < 0) cat = find_category(kSettingsDefaultCategory);

        Entry& e = g_entries[g_entry_count++];
        e.item = i;
        e.category = cat;
        e.icon = item.icon_path[0]
            ? svg_load(item.icon_path, TILE_ICON, TILE_ICON, colors::ICON_COLOR)
            : SvgIcon{};
        g_categories[cat].count++;
    }

    // Sort the extra categories by name, keeping each entry's index right.
    for (int i = fixed + 1; i < g_category_count; i++) {
        for (int j = i; j > fixed &&
             app_catalog_compare_ci(g_categories[j].name, g_categories[j - 1].name) < 0; j--) {
            Category tmp = g_categories[j];
            g_categories[j] = g_categories[j - 1];
            g_categories[j - 1] = tmp;
            for (int e = 0; e < g_entry_count; e++) {
                if (g_entries[e].category == j) g_entries[e].category = j - 1;
                else if (g_entries[e].category == j - 1) g_entries[e].category = j;
            }
        }
    }

    // Entries in display order: by category, then by name.
    for (int i = 1; i < g_entry_count; i++) {
        Entry tmp = g_entries[i];
        int j = i - 1;
        while (j >= 0) {
            const Entry& prev = g_entries[j];
            int by_cat = prev.category - tmp.category;
            int by_name = app_catalog_compare_ci(g_ds->desktop_items[prev.item].name,
                                                 g_ds->desktop_items[tmp.item].name);
            if (by_cat < 0 || (by_cat == 0 && by_name <= 0)) break;
            g_entries[j + 1] = g_entries[j];
            j--;
        }
        g_entries[j + 1] = tmp;
    }

    for (int i = 0; i < g_category_count; i++) {
        if (g_categories[i].count > 0)
            g_categories[i].icon = load_symbolic(category_icon_path(g_categories[i].name));
    }
    g_icon_all = load_symbolic("view-app-grid-symbolic.svg");
    g_icon_search = load_symbolic("system-search-symbolic.svg");
    g_icon_clear = svg_load("0:/os/icons/window-close-symbolic.svg", 14, 14, colors::WHITE);
}

// ==== Search ====

// A query of only spaces is no search.
static bool searching() {
    for (const char* p = g_query; *p; p++)
        if (*p != ' ') return true;
    return false;
}

// How well entry e matches the query, lower is better, or -1 for no match.
// Every space-separated term must appear in the name, category, description
// or keywords; names that start with (or have a word starting with) the
// query rank first.
static int match_score(int e) {
    const DesktopItem& item = entry_item(e);
    const char* cat = g_categories[g_entries[e].category].name;

    const char* p = g_query;
    int first_len = -1;
    while (*p) {
        while (*p == ' ') p++;
        const char* term = p;
        while (*p && *p != ' ') p++;
        int len = (int)(p - term);
        if (len == 0) continue;
        if (first_len < 0) first_len = len;
        if (find_folded(item.name, term, len) < 0 && find_folded(cat, term, len) < 0 &&
            find_folded(item.description, term, len) < 0 &&
            find_folded(item.keywords, term, len) < 0)
            return -1;
    }
    if (first_len < 0) return -1;

    const char* first = g_query;
    while (*first == ' ') first++;
    int at = find_folded(item.name, first, first_len);
    if (at == 0) return 0;
    for (int i = 0; at >= 0 && item.name[i]; i++) {
        if (is_word_start(item.name, i) && find_folded(item.name + i, first, first_len) == 0)
            return 1;
    }
    if (at > 0) return 2;
    return 3;
}

// ==== Layout ====

// The scrolled pane right of the sidebar, less the side padding.
static Rect body_rect() {
    return {SIDEBAR_W + PAD, 0, g_win.width - SIDEBAR_W - PAD * 2, g_win.height};
}

static Rect search_rect() {
    return {12, 14, SIDEBAR_W - 24, SEARCH_H};
}

// The query's area, as mtk text input expects it (text starts at x + 8).
static Rect search_text_rect() {
    Rect sr = search_rect();
    int x = sr.x + SEARCH_TEXT_X - 8;
    int right = sr.x + sr.w - 8 - CLEAR_SIZE - 4;
    return {x, sr.y, right - x, sr.h};
}

static Rect clear_button_rect() {
    Rect sr = search_rect();
    return {sr.x + sr.w - 8 - CLEAR_SIZE, sr.y + (sr.h - CLEAR_SIZE) / 2, CLEAR_SIZE, CLEAR_SIZE};
}

// Sidebar rows: "All Settings", then each category that has pages.
static int sidebar_row_count() {
    int n = 1;
    for (int i = 0; i < g_category_count; i++)
        if (g_categories[i].count > 0) n++;
    return n;
}

static int sidebar_row_category(int row) {
    if (row == 0) return CAT_ALL;
    int seen = 0;
    for (int i = 0; i < g_category_count; i++) {
        if (g_categories[i].count == 0) continue;
        if (++seen == row) return i;
    }
    return CAT_NONE;
}

static Rect sidebar_row_rect(int row) {
    return {6, CAT_TOP + row * CAT_ROW_H, SIDEBAR_W - 13, CAT_ROW_H - 2};
}

static int sidebar_category_at(int x, int y) {
    for (int row = 0; row < sidebar_row_count(); row++)
        if (sidebar_row_rect(row).contains(x, y)) return sidebar_row_category(row);
    return CAT_NONE;
}

static void relayout() {
    // Which entries show, in order.
    int order[MAX_ENTRIES];
    int count = 0;
    if (searching()) {
        int scores[MAX_ENTRIES];
        for (int e = 0; e < g_entry_count; e++) {
            int s = match_score(e);
            if (s < 0) continue;
            // Insertion by score; entries are already in category/name order.
            int j = count++;
            while (j > 0 && scores[j - 1] > s) {
                order[j] = order[j - 1];
                scores[j] = scores[j - 1];
                j--;
            }
            order[j] = e;
            scores[j] = s;
        }
    } else {
        for (int e = 0; e < g_entry_count; e++)
            if (g_category == CAT_ALL || g_entries[e].category == g_category) order[count++] = e;
    }
    g_result_count = count;

    Rect body = body_rect();
    int cols = (body.w + TILE_GAP) / (TILE_MIN_W + TILE_GAP);
    if (cols < 1) cols = 1;
    int tile_w = (body.w - (cols - 1) * TILE_GAP) / cols;
    bool grouped = !searching() && g_category == CAT_ALL;

    g_placed_count = 0;
    int y = HEADER_H, col = 0, prev_cat = -1;
    for (int i = 0; i < count && g_placed_count < MAX_PLACED; i++) {
        int e = order[i];
        if (grouped && g_entries[e].category != prev_cat) {
            if (col != 0) { y += TILE_H + TILE_GAP; col = 0; }
            prev_cat = g_entries[e].category;
            g_placed[g_placed_count++] = {PLACED_HEADING, prev_cat, {body.x, y, body.w, GROUP_H}};
            y += GROUP_H;
            if (g_placed_count >= MAX_PLACED) break;
        }
        Rect r = {body.x + col * (tile_w + TILE_GAP), y, tile_w, TILE_H};
        g_placed[g_placed_count++] = {PLACED_TILE, e, r};
        if (++col == cols) { col = 0; y += TILE_H + TILE_GAP; }
    }
    if (col != 0) y += TILE_H + TILE_GAP;
    g_content_h = y + PAD;

    int max_scroll = g_content_h - body.h;
    if (max_scroll < 0) max_scroll = 0;
    if (g_scroll > max_scroll) g_scroll = max_scroll;
    if (g_scroll < 0) g_scroll = 0;
    if (g_selected >= g_placed_count || (g_selected >= 0 && g_placed[g_selected].kind != PLACED_TILE))
        g_selected = -1;
    if (g_hover_tile >= g_placed_count) g_hover_tile = -1;
}

static Rect placed_on_screen(int i) {
    Rect r = g_placed[i].r;
    r.y -= g_scroll;
    return r;
}

static int tile_at(int x, int y) {
    for (int i = 0; i < g_placed_count; i++)
        if (g_placed[i].kind == PLACED_TILE && placed_on_screen(i).contains(x, y)) return i;
    return -1;
}

static int first_tile() {
    for (int i = 0; i < g_placed_count; i++)
        if (g_placed[i].kind == PLACED_TILE) return i;
    return -1;
}

static void scroll_into_view(int i) {
    if (i < 0) return;
    Rect body = body_rect();
    const Rect& r = g_placed[i].r;
    // A group's first tile brings its heading along, and the first group
    // the title header.
    int top = r.y;
    if (i > 0 && g_placed[i - 1].kind == PLACED_HEADING) top = g_placed[i - 1].r.y;
    if (i == first_tile()) top = 0;
    if (top < g_scroll) g_scroll = top;
    else if (r.y + r.h + TILE_GAP > g_scroll + body.h) g_scroll = r.y + r.h + TILE_GAP - body.h;
    relayout();
}

// ==== Actions ====

static void open_entry(int e) {
    if (e < 0 || e >= g_entry_count) return;
    gui::win_request_launch_item(g_win.id, entry_item(e).id);
}

static void select_category(int cat) {
    g_category = cat;
    g_query[0] = '\0';
    mtk::text_input_reset(g_search);
    g_scroll = 0;
    g_selected = -1;
    relayout();
}

static void query_changed() {
    g_scroll = 0;
    relayout();
    // Enter opens the best match.
    g_selected = searching() ? first_tile() : -1;
}

// Next tile in direction (dx, dy) from the selected one, by screen position.
static int neighbour_tile(int dx, int dy) {
    if (g_selected < 0) return first_tile();
    const Rect& cur = g_placed[g_selected].r;
    int best = -1;
    int best_primary = 0, best_secondary = 0;
    for (int i = 0; i < g_placed_count; i++) {
        if (i == g_selected || g_placed[i].kind != PLACED_TILE) continue;
        const Rect& r = g_placed[i].r;
        int primary, secondary;
        if (dy != 0) {
            primary = dy > 0 ? r.y - cur.y : cur.y - r.y;
            secondary = r.x > cur.x ? r.x - cur.x : cur.x - r.x;
        } else {
            if (r.y != cur.y) continue;
            primary = dx > 0 ? r.x - cur.x : cur.x - r.x;
            secondary = 0;
        }
        if (primary <= 0) continue;
        if (best < 0 || primary < best_primary ||
            (primary == best_primary && secondary < best_secondary)) {
            best = i;
            best_primary = primary;
            best_secondary = secondary;
        }
    }
    return best >= 0 ? best : g_selected;
}

// ==== Rendering ====

// A filled field with a leading magnifier that only shows the accent ring and
// caret while focused, and a clear button once there is a query.
static void draw_search(Canvas& c, const mtk::Theme& theme) {
    Rect sr = search_rect();
    int fh = system_font_height();
    if (g_search_focus) {
        mtk::fill_round_rect_aa(c, sr, SEARCH_RADIUS, g_accent);
        mtk::fill_round_rect_aa(c, {sr.x + 1, sr.y + 1, sr.w - 2, sr.h - 2},
                                SEARCH_RADIUS - 1, colors::WHITE);
    } else {
        mtk::fill_round_rect_aa(c, sr, SEARCH_RADIUS,
                                sr.contains(g_mouse_x, g_mouse_y) ? SEARCH_HOVER : SEARCH_BG);
    }

    if (g_icon_search.pixels)
        c.icon(sr.x + SEARCH_ICON_X, sr.y + (sr.h - g_icon_search.height) / 2, g_icon_search);

    Rect tr = search_text_rect();
    int tx = tr.x + 8;
    int ty = sr.y + (sr.h - fh) / 2;
    int len = mtk::text_input_len(g_query);
    if (g_search_focus && mtk::text_input_has_selection(g_search, g_query, sizeof(g_query))) {
        int sx = tx + mtk::text_input_prefix_width(
            g_query, mtk::text_input_selection_start(g_search, len), false);
        int ex = tx + mtk::text_input_prefix_width(
            g_query, mtk::text_input_selection_end(g_search, len), false);
        if (ex > tr.x + tr.w) ex = tr.x + tr.w;
        if (ex > sx) c.fill_rect(sx, sr.y + 6, ex - sx, sr.h - 12, theme.text_selection);
    }
    if (g_query[0]) c.text(tx, ty, g_query, theme.text);
    else c.text(tx, ty, "Search settings", theme.text_muted);
    if (g_search_focus) {
        int cx = tx + mtk::text_input_prefix_width(
            g_query, mtk::text_input_clamp_cursor(g_search.cursor, len), false);
        c.fill_rect(cx - 1, sr.y + 8, 2, sr.h - 16, g_accent);
    }

    if (g_query[0]) {
        Rect cb = clear_button_rect();
        mtk::fill_round_rect_aa(c, cb, CLEAR_SIZE / 2,
                                cb.contains(g_mouse_x, g_mouse_y) ? CLEAR_HOVER : CLEAR_BG);
        if (g_icon_clear.pixels)
            c.icon(cb.x + (cb.w - g_icon_clear.width) / 2,
                   cb.y + (cb.h - g_icon_clear.height) / 2, g_icon_clear);
    }
}

static void draw_sidebar(Canvas& c, const mtk::Theme& theme) {
    c.fill_rect(0, 0, SIDEBAR_W, g_win.height, SIDEBAR_BG);
    c.vline(SIDEBAR_W - 1, 0, g_win.height, theme.border);
    draw_search(c, theme);
    int fh = system_font_height();

    int rows = sidebar_row_count();
    for (int row = 0; row < rows; row++) {
        int cat = sidebar_row_category(row);
        Rect r = sidebar_row_rect(row);
        bool current = !searching() && cat == g_category;
        if (current)
            c.fill_rounded_rect(r.x, r.y, r.w, r.h, 4, mtk::accent_hover_tint(g_accent));
        else if (cat == g_hover_cat)
            c.fill_rounded_rect(r.x, r.y, r.w, r.h, 4, SIDEBAR_HOVER);

        const SvgIcon& icon = cat == CAT_ALL ? g_icon_all : g_categories[cat].icon;
        if (icon.pixels) c.icon(r.x + 10, r.y + (r.h - icon.height) / 2, icon);

        const char* label = cat == CAT_ALL ? "All Settings" : g_categories[cat].name;
        int count = cat == CAT_ALL ? g_entry_count : g_categories[cat].count;
        char count_text[8];
        snprintf(count_text, sizeof(count_text), "%d", count);
        int count_w = text_width(count_text);
        char fit[48];
        fit_text(label, fit, sizeof(fit), r.w - 34 - count_w - 16);
        int ty = r.y + (r.h - fh) / 2;
        c.text(r.x + 34, ty, fit, theme.text);
        c.text(r.x + r.w - 10 - count_w, ty, count_text, theme.text_muted);
    }
}

static void draw_tile(Canvas& c, int i, const mtk::Theme& theme) {
    Rect r = placed_on_screen(i);
    if (r.y + r.h <= 0 || r.y >= g_win.height) return;
    int e = g_placed[i].ref;
    const DesktopItem& item = entry_item(e);
    bool hovered = i == g_hover_tile;
    bool selected = i == g_selected && (g_grid_focus || searching());

    mtk::draw_rounded_frame(c, r, theme.radius_md + 2,
                            hovered ? theme.surface_hover : theme.surface,
                            selected ? theme.accent : theme.border);
    if (selected)
        mtk::draw_rounded_frame(c, {r.x + 1, r.y + 1, r.w - 2, r.h - 2}, theme.radius_md + 1,
                                hovered ? theme.surface_hover : theme.surface, theme.accent);

    const SvgIcon& icon = g_entries[e].icon;
    if (icon.pixels) c.icon(r.x + 16, r.y + (r.h - icon.height) / 2, icon);

    int fh = system_font_height();
    int tx = r.x + 16 + TILE_ICON + 14;
    int text_w = r.w - (tx - r.x) - 14;
    int name_y = r.y + (r.h - fh * 2 - 2) / 2;

    // Name, then the description (led by the category when the results mix
    // categories).
    char name[48];
    fit_text(item.name, name, sizeof(name), text_w,
             fonts::system_bold ? fonts::system_bold : fonts::system_font, fonts::UI_SIZE);
    draw_bold(c, tx, name_y, name, theme.text, fonts::UI_SIZE);

    char line[128];
    if (searching())
        snprintf(line, sizeof(line), "%s%s%s", g_categories[g_entries[e].category].name,
                 item.description[0] ? " - " : "", item.description);
    else
        montauk::strncpy(line, item.description[0] ? item.description : "Open settings",
                         sizeof(line));
    char desc[128];
    fit_text(line, desc, sizeof(desc), text_w);
    c.text(tx, name_y + fh + 2, desc, theme.text_subtle);
}

static void draw_body(Canvas& c, const mtk::Theme& theme) {
    int fh = system_font_height();
    for (int i = 0; i < g_placed_count; i++) {
        if (g_placed[i].kind == PLACED_TILE) {
            draw_tile(c, i, theme);
            continue;
        }
        Rect r = placed_on_screen(i);
        if (r.y + r.h <= 0 || r.y >= g_win.height) continue;
        const Category& cat = g_categories[g_placed[i].ref];
        int ty = r.y + r.h - fh - 10;
        if (cat.icon.pixels) c.icon(r.x, ty + (fh - cat.icon.height) / 2, cat.icon);
        c.text(r.x + 24, ty, cat.name, theme.text_subtle);
    }

    if (g_result_count == 0) {
        Rect body = body_rect();
        const char* msg = searching() ? "Try another word, such as \"display\" or \"wifi\"."
                                      : "Nothing to show here.";
        c.text(body.x + (body.w - text_width(msg)) / 2, HEADER_H + 48 - g_scroll, msg,
               theme.text_muted);
    }

    Rect body = body_rect();
    if (mtk::scrollbar_needed(g_content_h, body.h)) {
        Rect view = {SIDEBAR_W, 0, g_win.width - SIDEBAR_W, body.h};
        Rect track = mtk::scrollbar_track_rect(view);
        Rect thumb = mtk::scrollbar_thumb_rect(track, g_content_h, body.h, g_scroll);
        mtk::draw_scrollbar(c, track, thumb, false, false, theme);
    }
}

static void draw_header(Canvas& c, const mtk::Theme& theme) {
    // Part of the scrolled pane: it scrolls away with the tiles.
    int x0 = SIDEBAR_W;
    int y0 = 20 - g_scroll;
    if (y0 + HEADER_H <= 0) return;

    char title[96];
    char subtitle[128];
    if (searching()) {
        montauk::strcpy(title, "Search Results");
        if (g_result_count == 0)
            snprintf(subtitle, sizeof(subtitle), "No settings match \"%s\"", g_query);
        else
            snprintf(subtitle, sizeof(subtitle), "%d %s for \"%s\" - press Enter to open the first",
                     g_result_count, g_result_count == 1 ? "result" : "results", g_query);
    } else if (g_category == CAT_ALL) {
        montauk::strcpy(title, "All Settings");
        int cats = 0;
        for (int i = 0; i < g_category_count; i++)
            if (g_categories[i].count > 0) cats++;
        snprintf(subtitle, sizeof(subtitle), "%d settings in %d categories",
                 g_entry_count, cats);
    } else {
        montauk::strncpy(title, g_categories[g_category].name, sizeof(title));
        int n = g_categories[g_category].count;
        snprintf(subtitle, sizeof(subtitle), "%d %s", n, n == 1 ? "setting" : "settings");
    }

    int tx = x0 + PAD;
    int max_w = g_win.width - tx - PAD;
    char fit[128];
    TrueTypeFont* bold = fonts::system_bold ? fonts::system_bold : fonts::system_font;
    fit_text(title, fit, sizeof(fit), max_w, bold, TITLE_SIZE);
    draw_bold(c, tx, y0, fit, theme.text, TITLE_SIZE);
    fit_text(subtitle, fit, sizeof(fit), max_w);
    c.text(tx, y0 + gui::text_height(bold, TITLE_SIZE) + 6, fit, theme.text_subtle);
}

static void render() {
    mtk::StandaloneHost host(&g_win);
    Canvas c = host.canvas();
    mtk::Theme theme = app_theme();
    c.fill(theme.window_bg);
    draw_header(c, theme);
    draw_body(c, theme);
    draw_sidebar(c, theme);
    if (g_search.context.open)
        mtk::draw_text_input_context_menu(
            c, g_search, theme, mtk::text_input_has_selection(g_search, g_query, sizeof(g_query)));
    host.present();
}

// ==== Input ====

// The query stops growing once it fills the field (the field does not scroll).
static bool query_fits() {
    return text_width(g_query) <= search_text_rect().w - 8 - 2;
}

static void focus_search(bool select_all) {
    g_search_focus = true;
    g_grid_focus = false;
    if (select_all) {
        g_search.selection_anchor = 0;
        g_search.cursor = mtk::text_input_len(g_query);
    }
}

static void clear_query() {
    g_query[0] = '\0';
    mtk::text_input_reset(g_search);
    query_changed();
}

// True if the key changed the query.
static bool edit_query(const montauk::abi::KeyEvent& key) {
    char before[sizeof(g_query)];
    montauk::memcpy(before, g_query, sizeof(g_query));
    mtk::TextInputState saved = g_search;
    int r = mtk::text_input_key(g_search, g_query, sizeof(g_query), key);
    if (!(r & mtk::TEXT_INPUT_CHANGED)) return false;
    if (!query_fits()) {
        montauk::memcpy(g_query, before, sizeof(g_query));
        g_search = saved;
        return false;
    }
    query_changed();
    return true;
}

static void handle_key(const montauk::abi::KeyEvent& key) {
    if (!key.pressed) return;
    uint8_t nav = montauk::nav_scancode(key);

    if (key.scancode == 0x01) {   // Escape
        if (g_search.context.open) mtk::context_menu_close(g_search.context);
        else if (g_grid_focus) focus_search(false);
        else if (g_query[0]) clear_query();
        else if (g_search_focus) g_search_focus = false;
        else g_win.closed = true;
        return;
    }
    if (key.scancode == 0x1C) {   // Enter
        if (g_selected >= 0) open_entry(g_placed[g_selected].ref);
        return;
    }
    if (key.ctrl && (key.ascii == 'f' || key.ascii == 'F')) {
        focus_search(true);
        return;
    }
    if (key.scancode == 0x0F) {   // Tab
        if (g_grid_focus) {
            focus_search(false);
            return;
        }
        g_grid_focus = true;
        g_search_focus = false;
        if (g_selected < 0) g_selected = first_tile();
        scroll_into_view(g_selected);
        return;
    }

    if (g_grid_focus) {
        int next = -1;
        if (nav == 0x48) next = neighbour_tile(0, -1);
        else if (nav == 0x50) next = neighbour_tile(0, 1);
        else if (nav == 0x4B) next = neighbour_tile(-1, 0);
        else if (nav == 0x4D) next = neighbour_tile(1, 0);
        if (next >= 0 || nav == 0x48 || nav == 0x50 || nav == 0x4B || nav == 0x4D) {
            // Up from the top row returns to the search field.
            if (nav == 0x48 && next == g_selected) focus_search(false);
            else g_selected = next;
            scroll_into_view(g_selected);
            return;
        }
        // Anything else types into the search field.
        g_grid_focus = false;
    } else if (nav == 0x50) {     // Down: into the results
        g_grid_focus = true;
        g_search_focus = false;
        if (g_selected < 0) g_selected = first_tile();
        scroll_into_view(g_selected);
        return;
    }
    // Typing anywhere searches.
    if (edit_query(key)) g_search_focus = true;
}

static void handle_mouse(const montauk::abi::WinEvent& ev) {
    g_mouse_x = ev.mouse.x;
    g_mouse_y = ev.mouse.y;
    uint8_t buttons = ev.mouse.buttons, prev = ev.mouse.prev_buttons;
    bool pressed = (buttons & 1) && !(prev & 1);

    // The search field (and its Cut/Copy/Paste menu) sees the event first.
    Rect sr = search_rect();
    Rect tr = search_text_rect();
    bool in_search = sr.contains(g_mouse_x, g_mouse_y);
    bool in_text = tr.contains(g_mouse_x, g_mouse_y);
    if (pressed && g_query[0] && !g_search.context.open &&
        clear_button_rect().contains(g_mouse_x, g_mouse_y)) {
        clear_query();
        focus_search(false);
        return;
    }
    if (g_search.context.open || g_search.dragging || in_text) {
        char before[sizeof(g_query)];
        montauk::memcpy(before, g_query, sizeof(g_query));
        int r = mtk::text_input_handle_mouse(g_search, tr, g_query, sizeof(g_query),
                                             g_mouse_x, g_mouse_y, buttons, prev,
                                             g_win.width, g_win.height, g_search_focus);
        if ((r & mtk::TEXT_INPUT_CONSUMED) && in_text) focus_search(false);
        if (r & mtk::TEXT_INPUT_CHANGED) {
            if (!query_fits()) {
                montauk::memcpy(g_query, before, sizeof(g_query));
                mtk::text_input_reset(g_search, mtk::text_input_len(g_query));
            }
            query_changed();
        }
        if (r != mtk::TEXT_INPUT_NONE) return;
    }
    // The magnifier and padding focus the field too, caret at the end.
    if (pressed && in_search) {
        focus_search(false);
        mtk::text_input_reset(g_search, mtk::text_input_len(g_query));
        return;
    }

    if (ev.mouse.scroll != 0 && g_mouse_x >= SIDEBAR_W) {
        g_scroll -= ev.mouse.scroll * SCROLL_STEP;
        relayout();
    }

    g_hover_tile = tile_at(g_mouse_x, g_mouse_y);
    g_hover_cat = g_mouse_x < SIDEBAR_W ? sidebar_category_at(g_mouse_x, g_mouse_y) : CAT_NONE;

    if (!pressed) return;
    // A click anywhere else takes focus off the field.
    g_search_focus = false;
    if (g_hover_cat != CAT_NONE) {
        select_category(g_hover_cat);
        g_grid_focus = false;
    } else if (g_hover_tile >= 0) {
        g_selected = g_hover_tile;
        open_entry(g_placed[g_hover_tile].ref);
    }
}

extern "C" void _start() {
    if (!fonts::init()) montauk::exit(1);
    g_accent = mtk::load_system_accent();

    g_ds = (DesktopState*)montauk::malloc(sizeof(DesktopState));
    if (!g_ds) montauk::exit(1);
    montauk::memset(g_ds, 0, sizeof(DesktopState));
    load_identity();
    load_catalog();

    if (!g_win.create("Settings", WIN_W, WIN_H)) montauk::exit(1);
    relayout();
    render();
    while (g_win.id >= 0 && !g_win.closed) {
        montauk::abi::WinEvent ev;
        int result = g_win.poll(&ev);
        if (result < 0) break;
        if (result == 0) {
            montauk::sleep_ms(16);
            continue;
        }
        if (ev.type == montauk::abi::WIN_EVENT_CLOSE) break;
        if (ev.type == montauk::abi::WIN_EVENT_MOUSE) handle_mouse(ev);
        else if (ev.type == montauk::abi::WIN_EVENT_KEY) handle_key(ev.key);
        else if (ev.type == montauk::abi::WIN_EVENT_RESIZE) relayout();
        render();
    }
    g_win.destroy();
    montauk::exit(0);
}