/*
 * main.cpp
 * MontaukOS Printers - standalone Window Server app
 * Copyright (c) 2026 Daniel Hammer
 */

#include <montauk/config.h>
#include <montauk/heap.h>
#include <montauk/string.h>
#include <montauk/syscall.h>
#include <gui/gui.hpp>
#include <gui/canvas.hpp>
#include <gui/mtk.hpp>
#include <gui/mtk/settings.hpp>
#include <gui/svg.hpp>
#include <gui/standalone.hpp>
#include <gui/truetype.hpp>
#include <print/print.hpp>

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

using namespace gui;
using namespace print;

static constexpr int INIT_W = 560;
static constexpr int INIT_H = 500;
static constexpr int CONFIG_W = 408;
static constexpr int CONFIG_H = 220;
static constexpr int TAB_BAR_H = 36;
static constexpr int PAD_X = 16;
static constexpr int PAD_Y = 20;
static constexpr int BTN_H = 30;
static constexpr int FIELD_H = 32;
static constexpr int PRINTER_ICON_SIZE = 24;

enum PrinterTab {
    TAB_OVERVIEW = 0,
    TAB_DETAILS  = 1,
    TAB_COUNT    = 2,
};

static const char* g_tab_labels[TAB_COUNT] = {
    "Overview",
    "Details",
};

struct AppState {
    int active_tab;
    char printer_uri[MAX_PATH_LEN];
    bool printers_loaded;
    bool daemon_running;
    int daemon_pid;
    int queue_count;
    int active_count;
    int done_count;
    int failed_count;
    uint64_t last_refresh_ms;

    JobMeta last_active;
    JobMeta last_failed;
    bool has_active;
    bool has_failed;

    IppCapabilities probe_caps;
    bool probe_valid;
    bool probe_ok;
    char probe_message[128];
    char probe_time[32];
    char probe_detail[MAX_DEBUG_LEN];

    char status_msg[128];
    uint64_t status_time;

    bool config_open;
    int config_button_down;
    char edit_uri[MAX_PATH_LEN];
    int edit_len;
    mtk::TextInputState edit_input;
    char edit_error[128];
    int mouse_x;
    int mouse_y;
    int config_mouse_x;
    int config_mouse_y;

    Color accent;
};

struct Layout {
    Rect configure_btn;
    Rect clear_btn;
    Rect probe_btn;
    Rect start_btn;
    Rect refresh_btn;
    Rect test_btn;
    Rect printer_icon;
};

struct ConfigLayout {
    int input_label_y;
    Rect input;
    Rect save_btn;
    Rect cancel_btn;
};

struct ConfigPopup {
    int win_id;
    uint32_t* pixels;
    int width;
    int height;
    bool open;
};

static WsWindow g_win;
static ConfigPopup g_config = {-1, nullptr, CONFIG_W, CONFIG_H, false};
static AppState g_app = {};
static SvgIcon g_printer_icon = {};

static void render_config_popup();

static void str_append(char* dst, const char* src, int max) {
    int len = montauk::slen(dst);
    int i = 0;
    while (src[i] && len < max - 1) dst[len++] = src[i++];
    dst[len] = '\0';
}

static bool status_visible() {
    return g_app.status_msg[0] &&
           (montauk::get_milliseconds() - g_app.status_time < 4000);
}

static void set_status(const char* msg) {
    montauk::strncpy(g_app.status_msg, msg ? msg : "", (int)sizeof(g_app.status_msg) - 1);
    g_app.status_time = montauk::get_milliseconds();
}

static void clear_probe() {
    montauk::memset(&g_app.probe_caps, 0, sizeof(g_app.probe_caps));
    g_app.probe_valid = false;
    g_app.probe_ok = false;
    g_app.probe_message[0] = '\0';
    g_app.probe_time[0] = '\0';
    g_app.probe_detail[0] = '\0';
}

static void apply_probe_state(const ProbeState& state) {
    g_app.probe_caps = state.caps;
    g_app.probe_valid = state.printer_uri[0] != '\0' || state.message[0] != '\0';
    g_app.probe_ok = state.ok;
    safe_copy(g_app.probe_message, sizeof(g_app.probe_message), state.message);
    safe_copy(g_app.probe_time, sizeof(g_app.probe_time), state.probed_at);
    safe_copy(g_app.probe_detail, sizeof(g_app.probe_detail), state.detail);
}

static void set_accent(Color accent) {
    g_app.accent = accent;
}

static mtk::Theme printers_theme() {
    mtk::Theme theme = mtk::make_theme(g_app.accent);
    theme.disabled_bg = Color::from_rgb(0xE6, 0xE6, 0xE6);
    theme.disabled_fg = Color::from_rgb(0x9A, 0x9A, 0x9A);
    return theme;
}

static void load_accent() {
    set_accent(mtk::load_system_accent());
}

static void load_icons() {
    if (g_printer_icon.pixels) svg_free(g_printer_icon);
    g_printer_icon = svg_load("0:/icons/printer-symbolic.svg",
                              PRINTER_ICON_SIZE, PRINTER_ICON_SIZE,
                              Color::from_rgb(0x6A, 0x72, 0x7D));
}

static int count_dir_entries(const char* path) {
    DIR* d = opendir(path);
    if (!d) return 0;

    int count = 0;
    struct dirent* ent = nullptr;
    while ((ent = readdir(d)) != nullptr) {
        if (ent->d_name[0] == '.') continue;
        count++;
    }
    closedir(d);
    return count;
}

static bool load_latest_job(const char* dir, JobMeta* out) {
    if (out) zero_job(out);
    DIR* d = opendir(dir);
    if (!d) return false;

    bool found = false;
    char best_key[32] = {};
    struct dirent* ent = nullptr;
    while ((ent = readdir(d)) != nullptr) {
        if (ent->d_name[0] == '.') continue;

        char path[MAX_PATH_LEN];
        path_join(path, sizeof(path), dir, ent->d_name);

        JobMeta job = {};
        if (!load_job_from_path(path, &job)) continue;

        const char* key = job.updated_at[0] ? job.updated_at : job.created_at;
        if (!found || strcmp(key, best_key) > 0) {
            found = true;
            safe_copy(best_key, sizeof(best_key), key);
            if (out) *out = job;
        }
    }

    closedir(d);
    return found;
}

static void text_fit(const char* src, char* out, int out_len, int max_w) {
    if (!src || !out || out_len <= 0) return;
    montauk::strncpy(out, src, out_len - 1);
    if (text_width(out) <= max_w) return;

    const char* ell = "...";
    int keep = montauk::slen(src);
    while (keep > 0) {
        char tmp[MAX_DEBUG_LEN];
        int n = keep < (int)sizeof(tmp) - 4 ? keep : (int)sizeof(tmp) - 4;
        for (int i = 0; i < n; i++) tmp[i] = src[i];
        tmp[n] = '\0';
        str_append(tmp, ell, (int)sizeof(tmp));
        if (text_width(tmp) <= max_w) {
            montauk::strncpy(out, tmp, out_len - 1);
            return;
        }
        keep--;
    }
    montauk::strncpy(out, ell, out_len - 1);
}

static void format_resolved_transport_line(const IppUri& uri, char* out, int out_len) {
    if (!out || out_len <= 0) return;
    out[0] = '\0';

    const char* transport = uri.use_tls ? "TLS" : "Plain TCP";
    uint32_t ip = 0;
    if (!parse_ipv4_literal(uri.host, &ip))
        ip = g_app.probe_caps.resolved_ip;

    if (ip != 0) {
        char ip_text[20];
        format_ipv4(ip_text, sizeof(ip_text), ip);
        snprintf(out, out_len, "Resolved: %s    Transport: %s", ip_text, transport);
        return;
    }

    if (host_looks_like_mdns(uri.host)) {
        snprintf(out, out_len,
                 "Resolved: unavailable (.local/mDNS not supported yet)    Transport: %s",
                 transport);
        return;
    }

    if (g_app.probe_valid)
        snprintf(out, out_len, "Resolved: unavailable    Transport: %s", transport);
    else
        snprintf(out, out_len, "Resolved: run Probe to resolve current printer    Transport: %s",
                 transport);
}

static bool main_mouse_in_rect(const Rect& rect) {
    return rect.contains(g_app.mouse_x, g_app.mouse_y);
}

static bool config_mouse_in_rect(const Rect& rect) {
    return rect.contains(g_app.config_mouse_x, g_app.config_mouse_y);
}

static mtk::WidgetState main_button_state(const Rect& rect, bool enabled, bool active = false) {
    return mtk::widget_state(active, main_mouse_in_rect(rect), enabled);
}

static mtk::WidgetState config_button_state(const Rect& rect, bool enabled, bool active = false) {
    return mtk::widget_state(active, config_mouse_in_rect(rect), enabled);
}

static int control_row_text_y(int row_y) {
    return row_y + (BTN_H - system_font_height()) / 2;
}

static int control_row_badge_y(int row_y) {
    return row_y + (BTN_H - mtk::badge_height()) / 2;
}

static void draw_overview_stat_row(Canvas& c, int x, int y, int w,
                                   const char* label, int value,
                                   const mtk::Theme& theme) {
    char value_buf[16];
    snprintf(value_buf, sizeof(value_buf), "%d", value);

    c.text(x, y, label, theme.text);
    int value_w = text_width(value_buf);
    c.text(x + w - value_w, y, value_buf, theme.text);
}

static void compute_layout(Layout* lo) {
    int sfh = system_font_height();
    int x = PAD_X;
    int y = TAB_BAR_H + PAD_Y;

    if (status_visible()) y += sfh + 12;

    lo->configure_btn = {0, 0, 0, 0};
    lo->clear_btn = {0, 0, 0, 0};
    lo->probe_btn = {0, 0, 0, 0};
    lo->start_btn = {0, 0, 0, 0};
    lo->refresh_btn = {0, 0, 0, 0};
    lo->test_btn = {0, 0, 0, 0};
    lo->printer_icon = {0, 0, 0, 0};

    if (g_app.active_tab == TAB_OVERVIEW) {
        int right_edge = g_win.width - x;
        lo->clear_btn = {right_edge - 84, y, 84, BTN_H};
        lo->configure_btn = {lo->clear_btn.x - 8 - 112, y, 112, BTN_H};
        if (g_app.probe_ok && g_app.probe_caps.printer_name[0] && g_printer_icon.pixels) {
            lo->printer_icon = {
                x,
                y + (BTN_H - PRINTER_ICON_SIZE) / 2,
                PRINTER_ICON_SIZE,
                PRINTER_ICON_SIZE
            };
        }

        y += BTN_H + 8;
        y += sfh + 4;
        y += sfh + 4;
        if (!g_app.probe_ok || !g_app.probe_caps.printer_name[0])
            y += sfh + 4;
        y += sfh + 14;
        y += 16;

        int queue_row_h = sfh + 10;
        y += sfh + 8;
        y += queue_row_h * 4;
        y += sfh + 8;
        if (g_app.has_failed) y += sfh + 4;
        if (!g_app.daemon_running) y += sfh + 4;
        y += 14;
        y += 16;

        lo->test_btn = {g_win.width - x - 132, y, 132, BTN_H};
    } else {
        lo->probe_btn = {g_win.width - x - 92, y, 92, BTN_H};

        y += BTN_H + 8;
        if (g_app.printer_uri[0]) {
            char err[128] = {};
            IppUri normalized = {};
            if (normalize_ipp_uri(g_app.printer_uri, &normalized, err, sizeof(err))) {
                y += sfh + 4;
                y += sfh + 4;
                y += sfh + 4;
                y += sfh + 4;
            } else {
                y += sfh + 4;
                y += sfh + 4;
            }
        } else {
            y += sfh + 4;
            y += sfh + 4;
        }
        y += sfh + 4;
        if (g_app.probe_time[0]) y += sfh + 4;
        if (g_app.probe_valid) {
            y += sfh + 4;
            if (g_app.probe_ok) y += sfh + 4;
            if (g_app.probe_caps.supported_formats[0]) y += sfh + 4;
            if (g_app.probe_detail[0]) y += sfh + 4;
        } else {
            y += sfh + 4;
        }
        y += 14;
        y += 16;

        lo->start_btn = {g_win.width - x - 118 - 8 - 86, y, 118, BTN_H};
        lo->refresh_btn = {lo->start_btn.x + 126, y, 86, BTN_H};

        y += BTN_H + 8;
        y += sfh + 6;
        y += sfh + 4;
        y += sfh + 4;
        if (g_app.has_active) y += sfh + 4;
        if (g_app.has_active && g_app.last_active.debug_info[0]) y += sfh + 4;
        if (g_app.has_failed) {
            y += sfh + 4;
            if (g_app.last_failed.debug_info[0]) y += sfh + 4;
        }
        y += 14;
        y += 16;
    }

}

static Rect tab_bar_rect() {
    return {0, 0, g_win.width, TAB_BAR_H};
}

static void compute_config_layout(ConfigLayout* lo) {
    mtk::Theme theme = printers_theme();
    int pad = 16;
    int sfh = system_font_height();
    int field_w = g_config.width - pad * 2;
    if (field_w < 120) field_w = 120;

    lo->input_label_y = 16 + sfh + 6 + sfh + 10;
    lo->input = mtk::labeled_text_input_rect(pad, lo->input_label_y, field_w, theme, FIELD_H);
    lo->save_btn = {pad, g_config.height - BTN_H - 16, 80, BTN_H};
    lo->cancel_btn = {pad + 88, g_config.height - BTN_H - 16, 80, BTN_H};
}

static bool refresh_state(bool force = false) {
    uint64_t now = montauk::get_milliseconds();
    if (!force && g_app.printers_loaded && now - g_app.last_refresh_ms < 1000) return false;

    bool was_loaded = g_app.printers_loaded;
    char old_printer_uri[MAX_PATH_LEN];
    safe_copy(old_printer_uri, sizeof(old_printer_uri), g_app.printer_uri);
    bool old_daemon_running = g_app.daemon_running;
    int old_daemon_pid = g_app.daemon_pid;
    int old_queue_count = g_app.queue_count;
    int old_active_count = g_app.active_count;
    int old_done_count = g_app.done_count;
    int old_failed_count = g_app.failed_count;
    JobMeta old_active = g_app.last_active;
    JobMeta old_failed = g_app.last_failed;
    bool old_has_active = g_app.has_active;
    bool old_has_failed = g_app.has_failed;
    IppCapabilities old_probe_caps = g_app.probe_caps;
    bool old_probe_valid = g_app.probe_valid;
    bool old_probe_ok = g_app.probe_ok;
    char old_probe_message[sizeof(g_app.probe_message)];
    char old_probe_time[sizeof(g_app.probe_time)];
    char old_probe_detail[sizeof(g_app.probe_detail)];
    safe_copy(old_probe_message, sizeof(old_probe_message), g_app.probe_message);
    safe_copy(old_probe_time, sizeof(old_probe_time), g_app.probe_time);
    safe_copy(old_probe_detail, sizeof(old_probe_detail), g_app.probe_detail);

    if (force || !g_app.printers_loaded)
        ensure_spool_dirs();

    if (!read_default_printer_uri(g_app.printer_uri, sizeof(g_app.printer_uri)))
        g_app.printer_uri[0] = '\0';

    ProbeState probe = {};
    if (g_app.printer_uri[0] && load_printer_probe_state(&probe) &&
        montauk::streq(probe.printer_uri, g_app.printer_uri))
        apply_probe_state(probe);
    else
        clear_probe();

    g_app.daemon_pid = -1;
    g_app.daemon_running = daemon_is_running(&g_app.daemon_pid);
    g_app.queue_count = count_dir_entries(SPOOL_QUEUE_DIR);
    g_app.active_count = count_dir_entries(SPOOL_ACTIVE_DIR);
    g_app.done_count = count_dir_entries(SPOOL_DONE_DIR);
    g_app.failed_count = count_dir_entries(SPOOL_FAILED_DIR);
    g_app.has_active = load_latest_job(SPOOL_ACTIVE_DIR, &g_app.last_active);
    g_app.has_failed = load_latest_job(SPOOL_FAILED_DIR, &g_app.last_failed);
    g_app.printers_loaded = true;
    g_app.last_refresh_ms = now;

    return !was_loaded
        || !montauk::streq(old_printer_uri, g_app.printer_uri)
        || old_daemon_running != g_app.daemon_running
        || old_daemon_pid != g_app.daemon_pid
        || old_queue_count != g_app.queue_count
        || old_active_count != g_app.active_count
        || old_done_count != g_app.done_count
        || old_failed_count != g_app.failed_count
        || old_has_active != g_app.has_active
        || (g_app.has_active && memcmp(&old_active, &g_app.last_active, sizeof(g_app.last_active)) != 0)
        || old_has_failed != g_app.has_failed
        || (g_app.has_failed && memcmp(&old_failed, &g_app.last_failed, sizeof(g_app.last_failed)) != 0)
        || old_probe_valid != g_app.probe_valid
        || old_probe_ok != g_app.probe_ok
        || !montauk::streq(old_probe_message, g_app.probe_message)
        || !montauk::streq(old_probe_time, g_app.probe_time)
        || !montauk::streq(old_probe_detail, g_app.probe_detail)
        || memcmp(&old_probe_caps, &g_app.probe_caps, sizeof(g_app.probe_caps)) != 0;
}

static void probe_printer() {
    ProbeState probe = {};
    char err[128] = {};
    bool ok = probe_printer_uri(g_app.printer_uri, &probe, err, sizeof(err));
    apply_probe_state(probe);
    if (probe.printer_uri[0]) save_printer_probe_state(&probe);
    set_status(ok ? "Printer probe succeeded" : (probe.message[0] ? probe.message : "Printer probe failed"));
}

static void close_config_popup() {
    if (g_config.open && g_config.win_id >= 0)
        montauk::win_destroy(g_config.win_id);
    g_config.win_id = -1;
    g_config.pixels = nullptr;
    g_config.width = CONFIG_W;
    g_config.height = CONFIG_H;
    g_config.open = false;
    g_app.config_open = false;
}

static void open_config_popup() {
    safe_copy(g_app.edit_uri, sizeof(g_app.edit_uri), g_app.printer_uri);
    g_app.edit_len = montauk::slen(g_app.edit_uri);
    mtk::text_input_reset(g_app.edit_input, g_app.edit_len);
    g_app.edit_error[0] = '\0';
    g_app.config_button_down = 0;
    g_app.config_mouse_x = -1;
    g_app.config_mouse_y = -1;

    if (!g_config.open) {
        Montauk::WinCreateResult wres;
        if (montauk::win_create("Configure Printer", CONFIG_W, CONFIG_H, &wres) < 0 || wres.id < 0) {
            set_status("Failed to open printer dialog");
            return;
        }
        g_config.win_id = wres.id;
        g_config.pixels = (uint32_t*)(uintptr_t)wres.pixelVa;
        g_config.width = CONFIG_W;
        g_config.height = CONFIG_H;
        g_config.open = true;
    }

    g_app.config_open = true;
    render_config_popup();
}

static void save_configured_printer() {
    if (g_app.edit_len == 0) {
        safe_copy(g_app.edit_error, sizeof(g_app.edit_error), "Printer URI is required");
        return;
    }

    char err[128] = {};
    IppUri uri = {};
    if (!normalize_ipp_uri(g_app.edit_uri, &uri, err, sizeof(err))) {
        safe_copy(g_app.edit_error, sizeof(g_app.edit_error), err);
        return;
    }

    if (!write_default_printer_uri(uri.normalized)) {
        safe_copy(g_app.edit_error, sizeof(g_app.edit_error), "Failed to save printer");
        return;
    }

    close_config_popup();
    refresh_state(true);
    set_status("Printer saved");
}

static void render_config_popup() {
    if (!g_app.config_open || !g_config.open || g_config.win_id < 0 || g_config.pixels == nullptr) return;

    Canvas c(g_config.pixels, g_config.width, g_config.height);
    mtk::Theme theme = printers_theme();
    c.fill(theme.window_bg);

    ConfigLayout lo = {};
    compute_config_layout(&lo);
    int sfh = system_font_height();
    int x = 16;
    int y = 16;
    c.text(x, y, "Default Printer", theme.text);
    y += sfh + 6;
    c.text(x, y, "Enter an IPP or IPPS destination URI.", theme.text_muted);

    mtk::draw_labeled_text_field(c, lo.input.x, lo.input_label_y, lo.input.w,
                                 "Printer URI", g_app.edit_uri,
                                 g_app.edit_input.cursor,
                                 true, false, theme, lo.input.h,
                                 g_app.edit_input.selection_anchor);

    y = lo.input.y + lo.input.h + 12;
    c.text(x, y, "Example: ipp://printer.local/ipp/print", theme.text_muted);
    y += sfh + 10;

    if (g_app.edit_error[0])
        c.text(x, y, g_app.edit_error, theme.danger);

    mtk::draw_modal_actions(c,
                            lo.save_btn, "Save",
                            mtk::BUTTON_PRIMARY,
                            config_button_state(lo.save_btn, true, g_app.config_button_down == 1),
                            lo.cancel_btn, "Cancel",
                            config_button_state(lo.cancel_btn, true, g_app.config_button_down == 2),
                            theme);
    mtk::draw_text_input_context_menu(
        c, g_app.edit_input, theme,
        mtk::text_input_has_selection(g_app.edit_input,
                                      g_app.edit_uri, MAX_PATH_LEN));
    montauk::win_present(g_config.win_id);
}

static bool handle_config_mouse(int mx, int my, uint8_t buttons, uint8_t prev_buttons) {
    ConfigLayout lo = {};
    compute_config_layout(&lo);
    g_app.config_mouse_x = mx;
    g_app.config_mouse_y = my;

    bool left_pressed = (buttons & 1) && !(prev_buttons & 1);
    bool left_released = !(buttons & 1) && (prev_buttons & 1);
    bool right_pressed = (buttons & 2) && !(prev_buttons & 2);

    if (g_app.edit_input.context.open || g_app.edit_input.dragging) {
        int result = mtk::text_input_handle_mouse(g_app.edit_input, lo.input,
                                                  g_app.edit_uri, MAX_PATH_LEN,
                                                  mx, my, buttons, prev_buttons,
                                                  g_config.width, g_config.height,
                                                  true);
        if (result & mtk::TEXT_INPUT_CHANGED) {
            g_app.edit_len = mtk::text_input_len(g_app.edit_uri, MAX_PATH_LEN);
            g_app.edit_error[0] = '\0';
        }
        return false;
    }

    if (left_pressed || right_pressed) {
        if (lo.input.contains(mx, my)) {
            g_app.config_button_down = 0;
            int result = mtk::text_input_handle_mouse(g_app.edit_input, lo.input,
                                                      g_app.edit_uri, MAX_PATH_LEN,
                                                      mx, my, buttons, prev_buttons,
                                                      g_config.width, g_config.height,
                                                      true);
            if (result & mtk::TEXT_INPUT_CHANGED) {
                g_app.edit_len = mtk::text_input_len(g_app.edit_uri, MAX_PATH_LEN);
                g_app.edit_error[0] = '\0';
            }
            return false;
        }

        if (!left_pressed) return false;

        int button_down = 0;
        if (lo.save_btn.contains(mx, my))
            button_down = 1;
        else if (lo.cancel_btn.contains(mx, my))
            button_down = 2;
        g_app.config_button_down = button_down;
        return false;
    }

    if (!left_released) return false;

    int pressed = g_app.config_button_down;
    g_app.config_button_down = 0;

    if (pressed == 1 && lo.save_btn.contains(mx, my)) {
        save_configured_printer();
        return !g_app.config_open;
    }
    if (pressed == 2 && lo.cancel_btn.contains(mx, my)) {
        close_config_popup();
        return true;
    }
    return false;
}

static bool handle_config_key(const Montauk::KeyEvent& key) {
    if (!key.pressed) return false;

    if (key.scancode == 0x01) {
        close_config_popup();
        return true;
    }
    if (key.ascii == '\n' || key.ascii == '\r' || key.scancode == 0x1C) {
        save_configured_printer();
        return !g_app.config_open;
    }

    int result = mtk::text_input_key(g_app.edit_input, g_app.edit_uri,
                                     MAX_PATH_LEN, key);
    if (result & mtk::TEXT_INPUT_CHANGED) {
        g_app.edit_len = mtk::text_input_len(g_app.edit_uri, MAX_PATH_LEN);
        g_app.edit_error[0] = '\0';
    }
    return false;
}

static void render_overview(Canvas& c, const Layout& lo, const mtk::Theme& theme) {
    Color dim = theme.text_muted;
    Color success = Color::from_rgb(0x22, 0x88, 0x22);
    Color danger = theme.danger;
    Color quiet_bg = Color::from_rgb(0xE6, 0xE6, 0xE6);
    int sfh = system_font_height();
    int x = PAD_X;
    int y = TAB_BAR_H + PAD_Y;
    int w = g_win.width - 2 * x;
    int title_x = x;
    char title[MAX_DEBUG_LEN];

    if (status_visible()) {
        c.text(x, y, g_app.status_msg, theme.accent);
        y += sfh + 12;
    }

    const char* chip_label = "Not Set";
    Color chip_bg = quiet_bg;
    Color chip_fg = theme.text;
    if (g_app.printer_uri[0] && g_app.probe_ok) {
        chip_label = "Ready";
        chip_bg = success;
        chip_fg = colors::WHITE;
    } else if (g_app.printer_uri[0] && g_app.probe_valid) {
        chip_label = "Problem";
        chip_bg = danger;
        chip_fg = colors::WHITE;
    } else if (g_app.printer_uri[0]) {
        chip_label = "Checking";
        chip_bg = theme.accent_soft;
        chip_fg = theme.text;
    }

    int chip_w = mtk::badge_width(chip_label, theme);
    int chip_x = lo.configure_btn.x - chip_w - 12;
    if (chip_x < x + 74) chip_x = x + 74;

    if (lo.printer_icon.w > 0) {
        title_x = lo.printer_icon.x + lo.printer_icon.w + 10;
        if (chip_x < title_x + 80) chip_x = title_x + 80;
    }

    if (g_app.probe_ok && g_app.probe_caps.printer_name[0])
        safe_copy(title, sizeof(title), g_app.probe_caps.printer_name);
    else
        safe_copy(title, sizeof(title), "Printer");

    int title_max_w = chip_x - title_x - 12;
    if (title_max_w < 80) title_max_w = 80;
    text_fit(title, title, sizeof(title), title_max_w);

    if (lo.printer_icon.w > 0 && g_printer_icon.pixels)
        c.icon(lo.printer_icon.x, lo.printer_icon.y, g_printer_icon);
    c.text(title_x, control_row_text_y(y), title, theme.text);
    mtk::draw_badge(c, chip_x, control_row_badge_y(y), chip_label, chip_bg, chip_fg, theme);
    mtk::draw_button(c, lo.configure_btn, "Configure", mtk::BUTTON_PRIMARY,
                     main_button_state(lo.configure_btn, true), theme);
    mtk::draw_button(c, lo.clear_btn, "Clear", mtk::BUTTON_SECONDARY,
                     main_button_state(lo.clear_btn, g_app.printer_uri[0] != '\0'), theme);
    y += BTN_H + 8;

    char line[MAX_DEBUG_LEN];
    if (!g_app.probe_ok || !g_app.probe_caps.printer_name[0]) {
        if (g_app.printer_uri[0])
            safe_copy(line, sizeof(line), "Configured printer");
        else
            safe_copy(line, sizeof(line), "No printer configured");
        text_fit(line, line, sizeof(line), w);
        c.text(x, y, line, theme.text);
        y += sfh + 4;
    }

    if (g_app.printer_uri[0]) {
        text_fit(g_app.printer_uri, line, sizeof(line), w);
        c.text(x, y, line, dim);
    } else {
        c.text(x, y, "Choose an IPP or IPPS printer to start printing.", dim);
    }
    y += sfh + 4;

    if (!g_app.printer_uri[0]) {
        c.text(x, y, "The saved printer is shared system-wide through the spooler.", dim);
    } else if (g_app.probe_ok) {
        if (g_app.probe_caps.status_message[0])
            safe_copy(line, sizeof(line), g_app.probe_caps.status_message);
        else
            safe_copy(line, sizeof(line), "Printer is reachable and ready for queued jobs.");
        text_fit(line, line, sizeof(line), w);
        c.text(x, y, line, dim);
    } else if (g_app.probe_valid) {
        text_fit(g_app.probe_message, line, sizeof(line), w);
        c.text(x, y, line, danger);
    } else {
        c.text(x, y, "Waiting for the spooler to probe the configured printer.", dim);
    }
    y += sfh + 14;
    mtk::draw_separator(c, x, y, w, theme);
    y += 16;

    if (!g_app.printer_uri[0]) {
        c.text(x, y, "Queue and test-page controls appear after a printer is configured.", dim);
        return;
    }

    c.text(x, y, "Queue", theme.text);
    y += sfh + 8;

    int row_h = sfh + 10;
    draw_overview_stat_row(c, x, y, w, "Waiting", g_app.queue_count, theme);
    y += row_h;
    mtk::draw_separator(c, x, y - 5, w, theme);

    draw_overview_stat_row(c, x, y, w, "Printing", g_app.active_count, theme);
    y += row_h;
    mtk::draw_separator(c, x, y - 5, w, theme);

    draw_overview_stat_row(c, x, y, w, "Completed", g_app.done_count, theme);
    y += row_h;
    mtk::draw_separator(c, x, y - 5, w, theme);

    draw_overview_stat_row(c, x, y, w, "Failed", g_app.failed_count, theme);
    y += row_h;
    y += 2;

    if (g_app.has_active) {
        snprintf(line, sizeof(line), "Now printing: %s", g_app.last_active.job_name);
        text_fit(line, line, sizeof(line), w);
        c.text(x, y, line, dim);
        y += sfh + 4;
    } else if (g_app.queue_count > 0) {
        c.text(x, y, "Jobs are waiting to be picked up by the spooler.", dim);
        y += sfh + 4;
    } else {
        c.text(x, y, "No jobs in queue.", dim);
        y += sfh + 4;
    }

    if (g_app.has_failed) {
        snprintf(line, sizeof(line), "Last failure: %s", g_app.last_failed.status_message);
        text_fit(line, line, sizeof(line), w);
        c.text(x, y, line, danger);
        y += sfh + 4;
    }

    if (!g_app.daemon_running) {
        c.text(x, y, "Printing is paused until the spooler starts.", danger);
        y += sfh + 4;
    }

    y += 10;
    mtk::draw_separator(c, x, y, w, theme);
    y += 16;

    c.text(x, control_row_text_y(y), "Test Page", theme.text);
    mtk::draw_button(c, lo.test_btn, "Print Test Page", mtk::BUTTON_PRIMARY,
                     main_button_state(lo.test_btn, true), theme);
    y += BTN_H + 8;
    c.text(x, y, "Queue a simple test page through the print spooler.", dim);
    y += sfh + 4;
    c.text(x, y, "Uses the configured default printer.", theme.text);
}

static void render_details(Canvas& c, const Layout& lo, const mtk::Theme& theme) {
    Color dim = theme.text_muted;
    Color success = Color::from_rgb(0x22, 0x88, 0x22);
    Color danger = theme.danger;
    int sfh = system_font_height();
    int x = PAD_X;
    int y = TAB_BAR_H + PAD_Y;
    int w = g_win.width - 2 * x;
    char line[MAX_DEBUG_LEN];

    if (status_visible()) {
        c.text(x, y, g_app.status_msg, theme.accent);
        y += sfh + 12;
    }

    c.text(x, control_row_text_y(y), "Connection", theme.text);
    mtk::draw_button(c, lo.probe_btn, "Probe", mtk::BUTTON_SECONDARY,
                     main_button_state(lo.probe_btn, g_app.printer_uri[0] != '\0'), theme);
    y += BTN_H + 8;

    if (g_app.printer_uri[0]) {
        IppUri normalized = {};
        char err[128] = {};
        if (normalize_ipp_uri(g_app.printer_uri, &normalized, err, sizeof(err))) {
            text_fit(g_app.printer_uri, line, sizeof(line), w);
            c.text(x, y, line, theme.text);
            y += sfh + 4;

            snprintf(line, sizeof(line), "Host: %s", normalized.host);
            c.text(x, y, line, dim);
            y += sfh + 4;

            format_resolved_transport_line(normalized, line, sizeof(line));
            text_fit(line, line, sizeof(line), w);
            c.text(x, y, line, dim);
            y += sfh + 4;

            snprintf(line, sizeof(line), "Path: %s    Port: %u", normalized.path, (unsigned)normalized.port);
            text_fit(line, line, sizeof(line), w);
            c.text(x, y, line, dim);
        } else {
            c.text(x, y, "Printer URI is invalid", danger);
            y += sfh + 4;
            text_fit(err, line, sizeof(line), w);
            c.text(x, y, line, dim);
        }
    } else {
        c.text(x, y, "No printer configured", dim);
        y += sfh + 4;
        c.text(x, y, "Use Overview to configure the system printer.", dim);
    }
    y += sfh + 4;

    if (g_app.probe_time[0]) {
        snprintf(line, sizeof(line), "Last probe: %s", g_app.probe_time);
        c.text(x, y, line, dim);
        y += sfh + 4;
    }

    if (g_app.probe_valid) {
        if (g_app.probe_ok && g_app.probe_caps.printer_name[0])
            snprintf(line, sizeof(line), "Printer: %s", g_app.probe_caps.printer_name);
        else
            snprintf(line, sizeof(line), "Probe: %s",
                     g_app.probe_message[0] ? g_app.probe_message : (g_app.probe_ok ? "ok" : "failed"));
        text_fit(line, line, sizeof(line), w);
        c.text(x, y, line, g_app.probe_ok ? theme.text : danger);
        y += sfh + 4;

        if (g_app.probe_ok) {
            snprintf(line, sizeof(line), "Caps: PDF %s, JPEG %s, text %s",
                     g_app.probe_caps.supports_pdf ? "yes" : "no",
                     g_app.probe_caps.supports_jpeg ? "yes" : "no",
                     g_app.probe_caps.supports_text ? "yes" : "no");
            c.text(x, y, line, dim);
            y += sfh + 4;
        }

        if (g_app.probe_caps.supported_formats[0]) {
            snprintf(line, sizeof(line), "Formats: %s", g_app.probe_caps.supported_formats);
            text_fit(line, line, sizeof(line), w);
            c.text(x, y, line, dim);
            y += sfh + 4;
        }

        if (g_app.probe_detail[0]) {
            text_fit(g_app.probe_detail, line, sizeof(line), w);
            c.text(x, y, line, dim);
            y += sfh + 4;
        }
    } else {
        c.text(x, y, "Waiting for daemon auto-probe or run Probe.", dim);
        y += sfh + 4;
    }

    y += 10;
    mtk::draw_separator(c, x, y, w, theme);
    y += 16;

    c.text(x, control_row_text_y(y), "Spooler", theme.text);
    mtk::draw_button(c, lo.start_btn, "Start Daemon", mtk::BUTTON_TONAL,
                     main_button_state(lo.start_btn, !g_app.daemon_running), theme);
    mtk::draw_button(c, lo.refresh_btn, "Refresh", mtk::BUTTON_SECONDARY,
                     main_button_state(lo.refresh_btn, true), theme);

    const char* daemon_label = g_app.daemon_running ? "Running" : "Stopped";
    int chip_w = mtk::badge_width(daemon_label, theme);
    int chip_x = lo.start_btn.x - chip_w - 12;
    if (chip_x < x + 70) chip_x = x + 70;
    mtk::draw_badge(c, chip_x, control_row_badge_y(y), daemon_label,
                    g_app.daemon_running ? success : danger,
                    colors::WHITE, theme);
    y += BTN_H + 8;

    if (g_app.daemon_running)
        snprintf(line, sizeof(line), "Daemon PID %d", g_app.daemon_pid);
    else
        safe_copy(line, sizeof(line), "Spooler is not active");
    c.text(x, y, line, dim);
    y += sfh + 6;

    snprintf(line, sizeof(line), "Queued: %d    Printing: %d", g_app.queue_count, g_app.active_count);
    c.text(x, y, line, theme.text);
    y += sfh + 4;
    snprintf(line, sizeof(line), "Completed: %d    Failed: %d", g_app.done_count, g_app.failed_count);
    c.text(x, y, line, theme.text);
    y += sfh + 4;

    if (g_app.has_active) {
        snprintf(line, sizeof(line), "Active: %s", g_app.last_active.job_name);
        text_fit(line, line, sizeof(line), w);
        c.text(x, y, line, dim);
        y += sfh + 4;

        if (g_app.last_active.debug_info[0]) {
            snprintf(line, sizeof(line), "Debug: %s", g_app.last_active.debug_info);
            text_fit(line, line, sizeof(line), w);
            c.text(x, y, line, dim);
            y += sfh + 4;
        }
    }

    if (g_app.has_failed) {
        snprintf(line, sizeof(line), "Last failure: %s", g_app.last_failed.status_message);
        text_fit(line, line, sizeof(line), w);
        c.text(x, y, line, danger);
        y += sfh + 4;

        if (g_app.last_failed.debug_info[0]) {
            snprintf(line, sizeof(line), "Debug: %s", g_app.last_failed.debug_info);
            text_fit(line, line, sizeof(line), w);
            c.text(x, y, line, dim);
            y += sfh + 4;
        }
    }
}

static void render() {
    mtk::StandaloneHost host(&g_win);
    Canvas c = host.canvas();
    mtk::Theme theme = printers_theme();
    c.fill(theme.window_bg);
    Layout lo = {};
    compute_layout(&lo);
    mtk::draw_tab_bar(c, tab_bar_rect(), g_tab_labels, TAB_COUNT, g_app.active_tab, theme);

    switch (g_app.active_tab) {
    case TAB_OVERVIEW:
        render_overview(c, lo, theme);
        break;
    case TAB_DETAILS:
        render_details(c, lo, theme);
        break;
    }

    host.present();
}

static void handle_click(int mx, int my) {
    Layout lo = {};
    compute_layout(&lo);

    if (g_app.config_open)
        return;

    int tab = mtk::hit_tab_bar(tab_bar_rect(), TAB_COUNT, mx, my);
    if (tab >= 0) {
        g_app.active_tab = tab;
        return;
    }

    if (g_app.active_tab == TAB_OVERVIEW && lo.configure_btn.contains(mx, my)) {
        open_config_popup();
        return;
    }

    if (g_app.active_tab == TAB_OVERVIEW && g_app.printer_uri[0] && lo.clear_btn.contains(mx, my)) {
        if (montauk::fdelete(DEFAULT_PRINTER_PATH) < 0) set_status("Failed to clear printer");
        else {
            refresh_state(true);
            set_status("Printer cleared");
        }
        return;
    }

    if (g_app.active_tab == TAB_DETAILS && g_app.printer_uri[0] && lo.probe_btn.contains(mx, my)) {
        probe_printer();
        return;
    }

    if (g_app.active_tab == TAB_DETAILS && !g_app.daemon_running && lo.start_btn.contains(mx, my)) {
        char err[128] = {};
        if (ensure_daemon_running(err, sizeof(err))) {
            refresh_state(true);
            set_status("Print spooler started");
        } else {
            set_status(err[0] ? err : "Failed to start print spooler");
        }
        return;
    }

    if (g_app.active_tab == TAB_DETAILS && lo.refresh_btn.contains(mx, my)) {
        refresh_state(true);
        set_status("Printer status refreshed");
        return;
    }

    if (g_app.active_tab == TAB_OVERVIEW && g_app.printer_uri[0] && lo.test_btn.contains(mx, my)) {
        char job_id[48] = {};
        char err[128] = {};
        if (submit_test_page_job(nullptr, job_id, sizeof(job_id), err, sizeof(err))) {
            refresh_state(true);
            set_status("Test page queued");
        } else {
            set_status(err[0] ? err : "Failed to queue test page");
        }
        return;
    }
}

static bool hover_changed(const Rect& rect, bool enabled,
                          int prev_x, int prev_y, int next_x, int next_y) {
    if (!enabled) return false;
    return rect.contains(prev_x, prev_y) != rect.contains(next_x, next_y);
}

static bool handle_mouse(const Montauk::WinEvent& ev) {
    if (g_app.config_open)
        return false;

    Layout lo = {};
    compute_layout(&lo);

    int prev_x = g_app.mouse_x;
    int prev_y = g_app.mouse_y;
    g_app.mouse_x = ev.mouse.x;
    g_app.mouse_y = ev.mouse.y;

    bool redraw = false;
    if (g_app.active_tab == TAB_OVERVIEW) {
        redraw |= hover_changed(lo.configure_btn, true, prev_x, prev_y, g_app.mouse_x, g_app.mouse_y);
        redraw |= hover_changed(lo.clear_btn, g_app.printer_uri[0] != '\0',
                                prev_x, prev_y, g_app.mouse_x, g_app.mouse_y);
        redraw |= hover_changed(lo.test_btn, g_app.printer_uri[0] != '\0',
                                prev_x, prev_y, g_app.mouse_x, g_app.mouse_y);
    } else {
        redraw |= hover_changed(lo.probe_btn, g_app.printer_uri[0] != '\0',
                                prev_x, prev_y, g_app.mouse_x, g_app.mouse_y);
        redraw |= hover_changed(lo.start_btn, !g_app.daemon_running,
                                prev_x, prev_y, g_app.mouse_x, g_app.mouse_y);
        redraw |= hover_changed(lo.refresh_btn, true,
                                prev_x, prev_y, g_app.mouse_x, g_app.mouse_y);
    }

    bool clicked = (ev.mouse.buttons & 1) && !(ev.mouse.prev_buttons & 1);
    if (clicked) {
        handle_click(ev.mouse.x, ev.mouse.y);
        return true;
    }

    return redraw;
}

static void cycle_tab(int delta) {
    int next = g_app.active_tab + delta;
    while (next < 0) next += TAB_COUNT;
    while (next >= TAB_COUNT) next -= TAB_COUNT;
    g_app.active_tab = next;
}

static void handle_key(const Montauk::KeyEvent& key) {
    if (!key.pressed) return;

    if (g_app.config_open) {
        return;
    }

    if (key.scancode == 0x01) {
        g_win.closed = true;
        return;
    }

    if (key.scancode == 0x0F) {
        cycle_tab(key.shift ? -1 : 1);
        return;
    }

    if (key.scancode == 0x4B) {
        cycle_tab(-1);
        return;
    }

    if (key.scancode == 0x4D) {
        cycle_tab(1);
        return;
    }

    if (key.ascii == 'r' || key.ascii == 'R') {
        refresh_state(true);
        set_status("Printer status refreshed");
    } else if (key.ascii == 'p' || key.ascii == 'P') {
        if (g_app.printer_uri[0]) probe_printer();
    } else if (key.ascii == 't' || key.ascii == 'T') {
        if (g_app.printer_uri[0]) {
            char job_id[48] = {};
            char err[128] = {};
            if (submit_test_page_job(nullptr, job_id, sizeof(job_id), err, sizeof(err))) {
                refresh_state(true);
                set_status("Test page queued");
            } else {
                set_status(err[0] ? err : "Failed to queue test page");
            }
        }
    }
}

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

    montauk::memset(&g_app, 0, sizeof(g_app));
    g_app.active_tab = TAB_OVERVIEW;
    g_app.mouse_x = -1;
    g_app.mouse_y = -1;
    g_app.config_mouse_x = -1;
    g_app.config_mouse_y = -1;
    load_accent();
    load_icons();
    refresh_state(true);

    if (!g_win.create("Printers", INIT_W, INIT_H))
        montauk::exit(1);

    render();

    while (g_win.id >= 0 && !g_win.closed) {
        Montauk::WinEvent ev;
        bool redraw_config = false;
        bool redraw_main = false;

        if (g_app.config_open && g_config.open) {
            int cr = montauk::win_poll(g_config.win_id, &ev);
            if (cr < 0) {
                close_config_popup();
                redraw_main = true;
            } else if (cr > 0) {
                if (ev.type == 3) {
                    close_config_popup();
                    redraw_main = true;
                } else if (ev.type == 2 || ev.type == 4) {
                    if (ev.type == 2) {
                        g_config.width = ev.resize.w;
                        g_config.height = ev.resize.h;
                        g_config.pixels = (uint32_t*)(uintptr_t)montauk::win_resize(
                            g_config.win_id, ev.resize.w, ev.resize.h);
                    }
                    redraw_config = true;
                } else if (ev.type == 0) {
                    if (handle_config_key(ev.key))
                        redraw_main = true;
                    if (g_app.config_open)
                        redraw_config = true;
                } else if (ev.type == 1) {
                    if (handle_config_mouse(ev.mouse.x, ev.mouse.y,
                                            ev.mouse.buttons, ev.mouse.prev_buttons))
                        redraw_main = true;
                    if (g_app.config_open)
                        redraw_config = true;
                }
            }
        }

        int r = g_win.poll(&ev);
        if (r < 0) break;
        if (r == 0) {
            if (refresh_state(false))
                redraw_main = true;
            if (g_app.status_msg[0] && !status_visible()) {
                g_app.status_msg[0] = '\0';
                redraw_main = true;
            }

            if (redraw_main)
                render();
            if (redraw_config && g_app.config_open)
                render_config_popup();
            if (!redraw_main && !(redraw_config && g_app.config_open))
                montauk::sleep_ms(16);
            continue;
        }

        if (ev.type == 3) break;
        if (ev.type == 2 || ev.type == 4) redraw_main = true;

        if (ev.type == 0) {
            handle_key(ev.key);
            redraw_main = true;
        } else if (ev.type == 1) {
            redraw_main |= handle_mouse(ev);
        }

        if (redraw_main)
            render();
        if (redraw_config && g_app.config_open)
            render_config_popup();
    }

    close_config_popup();
    if (g_printer_icon.pixels) svg_free(g_printer_icon);
    g_win.destroy();
    montauk::exit(0);
}