//! The terminal widget: draws a libghostty-vt screen with Cairo/Pango and
//! feeds user input back to the session.
//!
//! Rendering is deliberately simple. Ghostty itself uses a GPU renderer with
//! a glyph atlas; here we walk the visible rows every frame and hand runs of
//! same-styled text to Pango. That is far slower in principle, but a terminal
//! grid is small and this keeps the proof of concept readable.

const std = @import("std");
const cairo = @import("cairo");
const gdk = @import("gdk");
const gio = @import("gio");
const glib = @import("glib");
const gobject = @import("gobject");
const gtk = @import("gtk");
const pango = @import("pango");
const pangocairo = @import("pangocairo");
const vt = @import("ghostty-vt");

const keymap = @import("key.zig");
const theme = @import("theme.zig");
const Pane = @import("Pane.zig");
const Session = @import("Session.zig");

const Terminal = @This();

/// Pango measures in 1/1024ths of a device unit.
const pango_scale: f64 = @floatFromInt(pango.SCALE);

/// The font we render with. Any monospace family the system provides.
const font_spec = "monospace 11";

/// Padding between the grid and the widget edge, in pixels.
const pad: f64 = 8;
const pad_px: u32 = @intFromFloat(pad);

/// Rows the viewport moves per wheel notch. Three is the conventional feel,
/// and it is also how many arrow keys a notch turns into for a pager.
const scroll_rows: f64 = 3;

/// How long after a click a second one still counts as a double-click.
/// GTK's own default for `gtk-double-click-time`.
const click_interval_ns: u64 = 400 * std.time.ns_per_ms;

/// Codepoints that end a word for double-click selection. Ghostty's default
/// set, which is tuned for what one actually double-clicks in a terminal:
/// paths and identifiers stay whole, shell punctuation does not. The leading
/// NUL is the empty cell, which always ends a word.
const word_boundaries = codepoints("\x00 \t'\"│`|:;,()[]{}<>$");

fn codepoints(comptime s: []const u8) []const u21 {
    comptime {
        var out: [s.len]u21 = undefined;
        var n: usize = 0;
        var it: std.unicode.Utf8Iterator = .{ .bytes = s, .i = 0 };
        while (it.nextCodepoint()) |cp| : (n += 1) out[n] = cp;
        const final = out[0..n].*;
        return &final;
    }
}

alloc: std.mem.Allocator,
session: *Session,

area: *gtk.DrawingArea,
font: *pango.FontDescription,

/// Cell geometry derived from the font metrics.
cell_w: f64 = 8,
cell_h: f64 = 16,
ascent: f64 = 12,

/// Pointer state. GTK reports events one at a time, but a mouse report has to
/// carry position, button and modifiers together, so what the current event
/// doesn't say has to be remembered from the ones before it.
mouse: Mouse = .{},

/// Click counting and drag anchoring for text selection. Owned by
/// libghostty-vt so that double-click-selects-word and friends behave the
/// way they do in Ghostty rather than the way I'd guess they should.
gesture: vt.SelectionGesture = .init,

/// Scratch buffer for building the UTF-8 of a single text run.
run_buf: std.ArrayListUnmanaged(u8) = .empty,

/// Called when the session's title changes, so the owner can retitle the tab.
on_title: *const fn (ctx: ?*anyopaque, title: []const u8) void,
on_exit: *const fn (ctx: ?*anyopaque) void,

/// Called when this terminal takes keyboard focus.
on_focus: *const fn (ctx: ?*anyopaque) void,

/// Called when the child reports a change of state, so the owner can show
/// it in the tab strip.
on_status: *const fn (ctx: ?*anyopaque, status: Status) void,

/// Called when the user types into this terminal. Focus isn't enough for
/// this: the owner uses it as the sign that whatever the session had to say
/// has been dealt with, and that is answering, not looking.
on_input: *const fn (ctx: ?*anyopaque) void,

ctx: ?*anyopaque = null,

/// What a layout can specify for a terminal pane.
pub const Options = Session.Options;

/// What the child is doing. Reported by the session; passed straight through.
pub const Status = Session.Status;

/// Which clipboard a copy goes to. X11 keeps two: the one Ctrl+C fills, and
/// the one that middle-click pastes from, which selecting text fills on its
/// own. Wayland and GTK preserve the distinction.
pub const Clipboard = enum { standard, primary };

/// Everything about the pointer that survives between GTK events.
const Mouse = struct {
    /// Last known position, in widget pixels.
    x: f64 = 0,
    y: f64 = 0,

    /// Modifiers as of the last event we saw.
    mods: vt.input.KeyMods = .{},

    /// Which buttons are held, indexed by the button's ordinal. Motion
    /// reports have to name the button being dragged, and the encoder needs
    /// to know whether anything at all is down to decide what to do with
    /// events that leave the widget.
    down: [12]bool = @splat(false),

    /// The last cell reported to the child. The encoder uses it to drop
    /// motion that hasn't crossed into a new cell, which is most of it.
    last_cell: ?vt.Coordinate = null,

    /// Wheel movement not yet worth a whole row. A trackpad sends fractions
    /// of a notch, and without this they would all round to nothing.
    pending_scroll: f64 = 0,

    /// Whether shift was held when the button went down. Latched for the
    /// length of the drag rather than read live, so that letting go of shift
    /// halfway through a selection doesn't hand the rest of it to a program
    /// that is tracking the mouse.
    override: bool = false,

    fn anyDown(self: Mouse) bool {
        return std.mem.indexOfScalar(bool, &self.down, true) != null;
    }

    /// The button to attribute a motion event to, or null when the pointer is
    /// just moving. Lowest-numbered wins, which is what every other terminal
    /// does when two buttons are held at once.
    fn dragging(self: Mouse) ?vt.input.MouseButton {
        const i = std.mem.indexOfScalar(bool, &self.down, true) orelse return null;
        return @enumFromInt(@as(c_int, @intCast(i)));
    }

    fn set(self: *Mouse, button: vt.input.MouseButton, held: bool) void {
        const i: usize = @intCast(@intFromEnum(button));
        if (i < self.down.len) self.down[i] = held;
    }
};

/// The renderer geometry the mouse encoder works in. Named off the encoder's
/// own field so this can't drift from the type it has to be.
const SurfaceSize = @FieldType(vt.input.MouseEncodeOptions, "size");

pub fn create(
    alloc: std.mem.Allocator,
    opts: Options,
    cbs: Pane.Callbacks,
) !*Terminal {
    const self = try alloc.create(Terminal);
    errdefer alloc.destroy(self);

    const area = gtk.DrawingArea.new();
    const font = pango.FontDescription.fromString(font_spec);

    self.* = .{
        .alloc = alloc,
        .session = undefined,
        .area = area,
        .font = font,
        .on_title = cbs.on_title,
        .on_exit = cbs.on_exit,
        .on_focus = cbs.on_focus,
        .on_status = cbs.on_status,
        .on_input = cbs.on_input,
        .ctx = cbs.ctx,
    };

    self.measureFont();

    // The grid size follows the widget size, but we need a starting point
    // for the session before the widget has ever been allocated.
    self.session = try .create(alloc, 80, 24, opts, .{
        .on_damage = &onDamage,
        .on_title = &onSessionTitle,
        .on_exit = &onSessionExit,
        .on_status = &onSessionStatus,
        .ctx = self,
    });
    errdefer self.session.destroy();

    const w = area.as(gtk.Widget);
    area.as(gobject.Object).setData(self_key, self);
    w.setHexpand(1);
    w.setVexpand(1);
    // Without this the drawing area can never hold keyboard focus, and all
    // key events would go to the sidebar instead.
    w.setFocusable(1);
    w.setCanFocus(1);

    // An I-beam over the grid, the way it is over any other text. Programs
    // that take the mouse for themselves get the arrow back — see `onMotion`.
    w.setCursorFromName("text");

    area.setDrawFunc(&drawFunc, self, null);
    _ = gtk.DrawingArea.signals.resize.connect(area, *Terminal, &onResize, self, .{});

    const keys = gtk.EventControllerKey.new();
    _ = gtk.EventControllerKey.signals.key_pressed.connect(
        keys,
        *Terminal,
        &onKeyPressed,
        self,
        .{},
    );
    w.addController(keys.as(gtk.EventController));

    const scroll = gtk.EventControllerScroll.new(.{ .vertical = true });
    _ = gtk.EventControllerScroll.signals.scroll.connect(
        scroll,
        *Terminal,
        &onScroll,
        self,
        .{},
    );
    w.addController(scroll.as(gtk.EventController));

    // Button 0 means every button rather than the left one alone: the middle
    // button pastes, and a program that has asked for mouse events wants to
    // hear about all of them.
    const click = gtk.GestureClick.new();
    click.as(gtk.GestureSingle).setButton(0);
    _ = gtk.GestureClick.signals.pressed.connect(
        click,
        *Terminal,
        &onPressed,
        self,
        .{},
    );
    _ = gtk.GestureClick.signals.released.connect(
        click,
        *Terminal,
        &onReleased,
        self,
        .{},
    );
    w.addController(click.as(gtk.EventController));

    const motion = gtk.EventControllerMotion.new();
    _ = gtk.EventControllerMotion.signals.motion.connect(
        motion,
        *Terminal,
        &onMotion,
        self,
        .{},
    );
    w.addController(motion.as(gtk.EventController));

    // Watching the property rather than just the click gesture means focus
    // taken programmatically or by keyboard navigation is reported too.
    _ = gobject.Object.signals.notify.connect(
        area,
        *Terminal,
        &onNotifyHasFocus,
        self,
        .{ .detail = "has-focus" },
    );

    return self;
}

pub fn destroy(self: *Terminal) void {
    // A clipboard read still in flight resolves through this link; cutting it
    // is what makes closing a pane mid-paste harmless.
    self.area.as(gobject.Object).setData(self_key, null);

    // Before the session: the gesture holds a pin tracked by the terminal's
    // page list, and releasing it afterwards would be a use-after-free.
    self.gesture.deinit(&self.session.term);
    self.session.destroy();
    self.run_buf.deinit(self.alloc);
    self.font.free();
    self.alloc.destroy(self);
}

pub fn widget(self: *Terminal) *gtk.Widget {
    return self.area.as(gtk.Widget);
}

pub fn grabFocus(self: *Terminal) void {
    _ = self.widget().grabFocus();
}

/// Derive cell geometry from the font. A monospace font's "approximate
/// character width" is its advance, which is exactly our cell width.
fn measureFont(self: *Terminal) void {
    const ctx = self.area.as(gtk.Widget).createPangoContext();
    defer ctx.unref();

    const metrics = ctx.getMetrics(self.font, null);
    defer metrics.unref();

    const ascent = @as(f64, @floatFromInt(metrics.getAscent())) / pango_scale;
    const descent = @as(f64, @floatFromInt(metrics.getDescent())) / pango_scale;
    const char_w = @as(f64, @floatFromInt(metrics.getApproximateCharWidth())) / pango_scale;

    self.cell_w = @max(1, @ceil(char_w));
    self.cell_h = @max(1, @ceil(ascent + descent));
    self.ascent = ascent;
}

fn onDamage(ctx: ?*anyopaque) void {
    const self: *Terminal = @ptrCast(@alignCast(ctx.?));
    self.area.as(gtk.Widget).queueDraw();
}

fn onSessionTitle(ctx: ?*anyopaque, title: []const u8) void {
    const self: *Terminal = @ptrCast(@alignCast(ctx.?));
    self.on_title(self.ctx, title);
}

fn onSessionStatus(ctx: ?*anyopaque, status: Status) void {
    const self: *Terminal = @ptrCast(@alignCast(ctx.?));
    self.on_status(self.ctx, status);
}

fn onNotifyHasFocus(
    _: *gtk.DrawingArea,
    _: *gobject.ParamSpec,
    self: *Terminal,
) callconv(.c) void {
    if (self.widget().hasFocus() != 0) self.on_focus(self.ctx);
}

fn onSessionExit(ctx: ?*anyopaque) void {
    const self: *Terminal = @ptrCast(@alignCast(ctx.?));
    self.on_exit(self.ctx);
}

/// The widget was resized: recompute the grid and tell the child process.
fn onResize(_: *gtk.DrawingArea, width: c_int, height: c_int, self: *Terminal) callconv(.c) void {
    const usable_w = @max(0.0, @as(f64, @floatFromInt(width)) - pad * 2);
    const usable_h = @max(0.0, @as(f64, @floatFromInt(height)) - pad * 2);

    const cols: u16 = @intFromFloat(@max(1, @floor(usable_w / self.cell_w)));
    const rows: u16 = @intFromFloat(@max(1, @floor(usable_h / self.cell_h)));

    self.session.resize(
        cols,
        rows,
        @intFromFloat(self.cell_w),
        @intFromFloat(self.cell_h),
    ) catch |err| {
        std.log.warn("resize failed: {s}", .{@errorName(err)});
    };
}

// -------------------------------------------------------------------------
// Mouse
//
// A terminal's pointer belongs to whichever of two parties has claimed it.
// Most of the time it is ours: dragging selects text, the wheel moves the
// scrollback. But a program can turn on mouse tracking (DEC modes 1000-1003),
// and from then on it wants the raw events itself — that is how a pager
// scrolls, how a TUI's buttons work, and how Claude Code's own scrolling
// works. Everything below is written around that split, and `mouseReporting`
// is the line between the two halves.
//
// Holding shift takes the pointer back from a program that has claimed it, so
// there is always a way to select text out of a full-screen application.

/// True when the program running here has asked to receive mouse events.
fn mouseReporting(self: *Terminal) bool {
    return self.session.term.flags.mouse_event != .none;
}

/// The renderer geometry the mouse encoder needs to turn a pixel position
/// into a cell. Read from the widget rather than cached: it is only wanted
/// while handling an event, by which point GTK has already allocated us.
fn surfaceSize(self: *Terminal) SurfaceSize {
    const w = self.widget();
    return .{
        .screen = .{
            .width = @intCast(@max(0, w.getWidth())),
            .height = @intCast(@max(0, w.getHeight())),
        },
        .cell = .{
            .width = @intFromFloat(self.cell_w),
            .height = @intFromFloat(self.cell_h),
        },
        .padding = .{
            .top = pad_px,
            .bottom = pad_px,
            .left = pad_px,
            .right = pad_px,
        },
    };
}

/// Send one mouse event to the child, in whichever of the four wire formats
/// it turned on. Silently does nothing when the program isn't listening, or
/// when this particular event isn't one the active mode reports.
fn mouseReport(
    self: *Terminal,
    button: ?vt.input.MouseButton,
    action: vt.input.MouseAction,
) void {
    if (!self.mouseReporting()) return;

    const term = &self.session.term;
    const opts: vt.input.MouseEncodeOptions = .{
        .event = term.flags.mouse_event,
        .format = term.flags.mouse_format,
        .size = self.surfaceSize(),
        .any_button_pressed = self.mouse.anyDown(),
        .last_cell = &self.mouse.last_cell,
    };

    // The longest encoding is SGR-pixels with four-digit coordinates, well
    // inside this.
    var buf: [64]u8 = undefined;
    var writer: std.Io.Writer = .fixed(&buf);
    vt.input.encodeMouse(&writer, .{
        .action = action,
        .button = button,
        .mods = self.mouse.mods,
        .pos = .{
            .x = @floatCast(self.mouse.x),
            .y = @floatCast(self.mouse.y),
        },
    }, opts) catch |err| {
        std.log.warn("mouse encode failed: {s}", .{@errorName(err)});
        return;
    };

    const encoded = writer.buffered();
    if (encoded.len == 0) return;
    self.session.write(encoded);
}

/// The libghostty button for a GDK button number. GTK4 delivers the wheel
/// through the scroll controller rather than as buttons 4 and 5, so the only
/// extras here are the side buttons.
fn buttonFromGdk(n: c_uint) ?vt.input.MouseButton {
    return switch (n) {
        1 => .left,
        2 => .middle,
        3 => .right,
        8 => .eight,
        9 => .nine,
        else => null,
    };
}

/// Record where the pointer is and what is held down. Every entry point does
/// this first, because the encoder reads position and modifiers off the
/// stored state rather than off the event.
fn trackPointer(self: *Terminal, ctrl: *gtk.EventController, x: f64, y: f64) void {
    self.mouse.x = x;
    self.mouse.y = y;
    self.mouse.mods = keymap.translateMods(ctrl.getCurrentEventState());
}

/// True when the user is overriding a program's claim on the pointer to
/// select text out of it. Mid-drag that is whatever was decided at press
/// time; otherwise it is simply whether shift is down now.
fn shiftOverride(self: *Terminal) bool {
    return if (self.mouse.anyDown()) self.mouse.override else self.mouse.mods.shift;
}

fn onPressed(
    click: *gtk.GestureClick,
    _: c_int,
    x: f64,
    y: f64,
    self: *Terminal,
) callconv(.c) void {
    self.grabFocus();

    const ctrl = click.as(gtk.EventController);
    self.trackPointer(ctrl, x, y);

    const button = buttonFromGdk(click.as(gtk.GestureSingle).getCurrentButton()) orelse return;
    if (!self.mouse.anyDown()) self.mouse.override = self.mouse.mods.shift;
    self.mouse.set(button, true);

    if (self.mouseReporting() and !self.shiftOverride()) {
        // A program that is tracking the mouse draws its own idea of a
        // selection; ours would be a second, stale one on top of it.
        self.clearSelection();
        self.mouseReport(button, .press);
        return;
    }

    switch (button) {
        // Middle-click pastes what was last selected, anywhere. This is the
        // X11 convention and it long predates the clipboard proper.
        .middle => self.pasteFrom(.primary),
        .left => self.selectPress(x, y),
        else => {},
    }
}

fn onReleased(
    click: *gtk.GestureClick,
    _: c_int,
    x: f64,
    y: f64,
    self: *Terminal,
) callconv(.c) void {
    const ctrl = click.as(gtk.EventController);
    self.trackPointer(ctrl, x, y);

    const button = buttonFromGdk(click.as(gtk.GestureSingle).getCurrentButton()) orelse return;

    // Read the override before clearing the button: with nothing held it
    // falls back to live shift, which is not what this release belongs to.
    const override = self.shiftOverride();
    self.mouse.set(button, false);

    if (self.mouseReporting() and !override) {
        self.mouseReport(button, .release);
        return;
    }

    if (button == .left) self.selectRelease(x, y);
}

fn onMotion(
    motion: *gtk.EventControllerMotion,
    x: f64,
    y: f64,
    self: *Terminal,
) callconv(.c) void {
    const ctrl = motion.as(gtk.EventController);
    self.trackPointer(ctrl, x, y);

    const theirs = self.mouseReporting() and !self.shiftOverride();

    // An I-beam invites a selection that a program tracking the mouse isn't
    // going to give you, so hand the pointer back its ordinary arrow while
    // one has the grid. Cheap enough to set on every motion; GTK compares.
    self.widget().setCursorFromName(if (theirs) "default" else "text");

    if (theirs) {
        // The encoder decides whether the active mode wants motion at all,
        // and drops anything still inside the last reported cell.
        self.mouseReport(self.mouse.dragging(), .motion);
        return;
    }

    if (self.mouse.down[@intFromEnum(vt.input.MouseButton.left)]) {
        self.selectDrag(x, y);
    }
}

fn onScroll(
    _: *gtk.EventControllerScroll,
    _: f64,
    dy: f64,
    self: *Terminal,
) callconv(.c) c_int {
    if (dy == 0) return 0;

    // A wheel notch arrives as ±1, a trackpad as a stream of fractions.
    // Accumulating means a slow trackpad drag still eventually moves a row
    // instead of rounding away to nothing every time.
    self.mouse.pending_scroll += dy * scroll_rows;
    const rows: isize = @intFromFloat(@trunc(self.mouse.pending_scroll));
    self.mouse.pending_scroll -= @floatFromInt(rows);
    if (rows == 0) return 1;

    const term = &self.session.term;

    // The program is tracking the mouse, so the wheel is theirs too: buttons
    // four and five are what the wheel is called on the wire.
    if (self.mouseReporting() and !self.shiftOverride()) {
        self.clearSelection();
        const button: vt.input.MouseButton = if (rows < 0) .four else .five;
        for (0..@abs(rows)) |_| self.mouseReport(button, .press);
        return 1;
    }

    // Alternate scroll. The alternate screen has no scrollback to move, so a
    // full-screen program that hasn't asked for mouse events gets arrow keys
    // instead — which is exactly what makes the wheel scroll in `less`, `man`
    // and everything else built on a pager.
    if (term.screens.active_key == .alternate and
        term.modes.get(.mouse_alternate_scroll))
    {
        const seq = if (term.modes.get(.cursor_keys))
            (if (rows < 0) "\x1bOA" else "\x1bOB")
        else
            (if (rows < 0) "\x1b[A" else "\x1b[B");
        for (0..@abs(rows)) |_| self.session.write(seq);
        return 1;
    }

    // Ours: move the viewport through the scrollback. The selection is left
    // alone, because its endpoints are pinned to the text rather than to the
    // screen and so they scroll with it.
    term.screens.active.pages.scroll(.{ .delta_row = rows });
    self.area.as(gtk.Widget).queueDraw();
    return 1;
}

// -------------------------------------------------------------------------
// Selection

/// The cell under a widget-space point, as a pin into the active screen.
/// Positions outside the grid clamp to its edge rather than failing, so a
/// drag that runs off the side still selects to the end of the line.
fn pinAt(self: *Terminal, x: f64, y: f64) ?vt.Pin {
    const term = &self.session.term;
    const max_col: f64 = @floatFromInt(term.cols - 1);
    const max_row: f64 = @floatFromInt(term.rows - 1);

    const col: u16 = @intFromFloat(@min(@max(0.0, x - pad) / self.cell_w, max_col));
    const row: u16 = @intFromFloat(@min(@max(0.0, y - pad) / self.cell_h, max_row));

    return term.screens.active.pages.pin(.{ .viewport = .{ .x = col, .y = row } });
}

/// The gesture wants a timestamp to tell a double-click from two clicks.
/// GLib's monotonic clock is the one GTK itself times clicks against.
fn now() std.Io.Timestamp {
    return .{ .nanoseconds = @as(i96, glib.getMonotonicTime()) * std.time.ns_per_us };
}

fn selectPress(self: *Terminal, x: f64, y: f64) void {
    const term = &self.session.term;
    const pin = self.pinAt(x, y) orelse return;

    // The gesture counts the clicks and picks the behaviour: one selects by
    // cell, two by word, three by line.
    const sel = self.gesture.press(term, .{
        .time = now(),
        .pin = pin,
        .xpos = x,
        .ypos = y,
        .max_distance = self.cell_w,
        .repeat_interval = click_interval_ns,
        .word_boundary_codepoints = word_boundaries,
    }) catch |err| {
        std.log.warn("selection press failed: {s}", .{@errorName(err)});
        return;
    };

    // A plain single click returns nothing: it is the start of a drag, and
    // until the drag happens its only effect is to drop what was selected.
    self.applySelection(sel);
}

fn selectDrag(self: *Terminal, x: f64, y: f64) void {
    const term = &self.session.term;
    const pin = self.pinAt(x, y) orelse return;

    const sel = self.gesture.drag(term, .{
        .pin = pin,
        .xpos = x,
        .ypos = y,
        .rectangle = self.mouse.mods.ctrl,
        .word_boundary_codepoints = word_boundaries,
        .geometry = .{
            .columns = term.cols,
            .cell_width = @intFromFloat(self.cell_w),
            .padding_left = pad_px,
            .screen_height = @intCast(@max(0, self.widget().getHeight())),
        },
    }) orelse return;

    self.applySelection(sel);
}

fn selectRelease(self: *Terminal, x: f64, y: f64) void {
    self.gesture.release(&self.session.term, .{ .pin = self.pinAt(x, y) });

    // Selecting fills the primary clipboard, so middle-click pastes what was
    // just highlighted without any explicit copy. The standard clipboard is
    // left for Ctrl+Shift+C, which is the only thing users expect to disturb
    // what they last copied.
    _ = self.copySelection(.primary);
}

fn applySelection(self: *Terminal, sel: ?vt.Selection) void {
    const screen = self.session.term.screens.active;
    if (sel == null and screen.selection == null) return;

    screen.select(sel) catch |err| {
        std.log.warn("selection failed: {s}", .{@errorName(err)});
        return;
    };
    self.area.as(gtk.Widget).queueDraw();
}

fn clearSelection(self: *Terminal) void {
    self.applySelection(null);
}

/// Put the selected text on a clipboard. Returns false when there was
/// nothing selected, so a copy shortcut can decline the key rather than
/// swallow it.
pub fn copySelection(self: *Terminal, which: Clipboard) bool {
    const screen = self.session.term.screens.active;
    const sel = screen.selection orelse return false;

    const text = screen.selectionString(self.alloc, .{ .sel = sel }) catch |err| {
        std.log.warn("selection copy failed: {s}", .{@errorName(err)});
        return false;
    };
    defer self.alloc.free(text);
    if (text.len == 0) return false;

    const w = self.widget();
    const clipboard = switch (which) {
        .standard => w.getClipboard(),
        .primary => w.getPrimaryClipboard(),
    };
    clipboard.setText(text.ptr);
    return true;
}

/// Read a clipboard and type it into the child. GTK4's clipboard API is
/// asynchronous, so this finishes on a later main loop turn — by which point
/// the pane may have been closed. The round trip therefore carries the
/// widget, reffed to keep it alive, and looks the terminal back up from it at
/// completion; `destroy` clears that link, so a paste into a pane that has
/// gone away resolves to nothing instead of to freed memory.
pub fn pasteFrom(self: *Terminal, which: Clipboard) void {
    const w = self.widget();
    const clipboard = switch (which) {
        .standard => w.getClipboard(),
        .primary => w.getPrimaryClipboard(),
    };

    const obj = w.as(gobject.Object);
    _ = obj.ref();
    clipboard.readTextAsync(null, &onPasteReady, obj);
}

/// Key the terminal is stored under on its own widget. See `pasteFrom`.
const self_key = "playpen-terminal";

fn onPasteReady(
    source: ?*gobject.Object,
    result: *gio.AsyncResult,
    data: ?*anyopaque,
) callconv(.c) void {
    const obj: *gobject.Object = @ptrCast(@alignCast(data.?));
    defer obj.unref();

    const clipboard: *gdk.Clipboard = @ptrCast(@alignCast(source.?));

    var err: ?*glib.Error = null;
    const text = clipboard.readTextFinish(result, &err) orelse {
        if (err) |e| {
            std.log.warn("paste failed: {s}", .{e.f_message orelse "unknown"});
            e.free();
        }
        return;
    };
    defer glib.free(text);

    const self: *Terminal = @ptrCast(@alignCast(obj.getData(self_key) orelse return));
    self.paste(std.mem.span(text));
}

/// Type text into the child as though it had been pasted, bracketing it if
/// the program asked for that.
pub fn paste(self: *Terminal, text: []const u8) void {
    const opts: vt.input.PasteOptions = .fromTerminal(&self.session.term);

    // Refuse pastes containing control characters that would execute on
    // arrival (a newline in unbracketed mode runs the command immediately).
    if (!vt.input.isSafePaste(text)) {
        std.log.warn("refusing unsafe paste", .{});
        return;
    }

    const parts = vt.input.encodePaste(text, opts) catch |err| {
        std.log.warn("paste encode failed: {s}", .{@errorName(err)});
        return;
    };
    for (parts) |part| self.session.write(part);
}

// -------------------------------------------------------------------------
// Keyboard

fn onKeyPressed(
    _: *gtk.EventControllerKey,
    keyval: c_uint,
    _: c_uint,
    state: gdk.ModifierType,
    self: *Terminal,
) callconv(.c) c_int {
    const mods = keymap.translateMods(state);

    var event: vt.input.KeyEvent = .{
        .action = .press,
        .key = keymap.keyFromKeyval(keyval) orelse .unidentified,
        .mods = mods,
    };

    // GDK has already applied the keyboard layout and shift level, so the
    // unicode value of the keyval is the text this key produces.
    var utf8_buf: [8]u8 = undefined;
    const codepoint = gdk.keyvalToUnicode(keyval);
    if (codepoint > 0) {
        if (std.unicode.utf8Encode(@intCast(codepoint), &utf8_buf)) |n| {
            event.utf8 = utf8_buf[0..n];
            // Shift is consumed producing the shifted character; ctrl/alt
            // are not, and the encoder needs to know that to build e.g.
            // ctrl sequences correctly.
            event.consumed_mods = .{ .shift = mods.shift };
        } else |_| {}

        const lower = gdk.keyvalToLower(keyval);
        const unshifted = gdk.keyvalToUnicode(lower);
        if (unshifted > 0) event.unshifted_codepoint = @intCast(unshifted);
    }

    var out: [128]u8 = undefined;
    var writer: std.Io.Writer = .fixed(&out);
    const opts: vt.input.KeyEncodeOptions = .fromTerminal(&self.session.term);
    vt.input.encodeKey(&writer, event, opts) catch |err| {
        std.log.warn("key encode failed: {s}", .{@errorName(err)});
        return 0;
    };

    const encoded = writer.buffered();
    // Keys with no terminal representation (bare modifiers, unmapped keys)
    // encode to nothing. Let GTK keep processing them.
    if (encoded.len == 0) return 0;

    // Typing should always snap the view back to the prompt, and a highlight
    // left over from before you started typing is only in the way.
    self.session.term.screens.active.pages.scroll(.active);
    self.clearSelection();
    self.session.write(encoded);
    self.on_input(self.ctx);
    self.area.as(gtk.Widget).queueDraw();
    return 1;
}

// -------------------------------------------------------------------------
// Rendering

/// A cell's appearance after resolving palette indices and SGR attributes.
const Appearance = struct {
    fg: theme.Rgb,
    bg: ?theme.Rgb,
    bold: bool,
    italic: bool,
    underline: bool,
    strikethrough: bool,

    fn sameRun(a: Appearance, b: Appearance) bool {
        return std.meta.eql(a.fg, b.fg) and
            a.bold == b.bold and
            a.italic == b.italic and
            a.underline == b.underline and
            a.strikethrough == b.strikethrough;
    }
};

/// The selection flattened to absolute screen coordinates.
///
/// `Selection.contains` walks the page list for the selection's two ends on
/// every call, which is fine for the occasional hit test and ruinous for one
/// per cell per frame. Resolving the ends once and comparing rows against
/// them costs one page-list walk per row instead.
const SelectionBounds = struct {
    tl: vt.Coordinate,
    br: vt.Coordinate,
    rectangle: bool,

    /// The inclusive column range the selection covers on the row at absolute
    /// screen row `y`, or null if the row is outside the selection.
    fn span(self: SelectionBounds, y: u32, cols: usize) ?[2]usize {
        if (y < self.tl.y or y > self.br.y) return null;
        if (self.rectangle) return .{ self.tl.x, self.br.x };
        return .{
            if (y == self.tl.y) self.tl.x else 0,
            if (y == self.br.y) self.br.x else cols -| 1,
        };
    }
};

fn inSpan(span: ?[2]usize, x: usize) bool {
    const s = span orelse return false;
    return x >= s[0] and x <= s[1];
}

/// A cell's appearance with the selection highlight applied on top. Kept
/// apart from `appearance` so that what the selection overrides can't be
/// mistaken for something the program running here asked for.
fn styled(
    pin: vt.Pin,
    cell: *const vt.Cell,
    term: *vt.Terminal,
    default_fg: theme.Rgb,
    default_bg: theme.Rgb,
    selected: bool,
) Appearance {
    var look = appearance(pin, cell, term, default_fg, default_bg);
    if (selected) {
        look.fg = theme.selectionFg();
        look.bg = theme.selectionBg();
    }
    return look;
}

fn drawFunc(
    _: *gtk.DrawingArea,
    cr: *cairo.Context,
    width: c_int,
    height: c_int,
    data: ?*anyopaque,
) callconv(.c) void {
    const self: *Terminal = @ptrCast(@alignCast(data.?));
    self.render(cr, width, height) catch |err| {
        std.log.warn("render failed: {s}", .{@errorName(err)});
    };
}

fn render(self: *Terminal, cr: *cairo.Context, _: c_int, _: c_int) !void {
    const term = &self.session.term;
    const screen = term.screens.active;

    // Background. The pane frame around us clips to its own rounded corners,
    // so this just fills.
    const default_bg: theme.Rgb = if (term.colors.background.get()) |c|
        .fromVt(c)
    else
        theme.bg();
    {
        const r, const g, const b = default_bg.cairoRgb();
        cr.setSourceRgb(r, g, b);
        cr.paint();
    }

    const default_fg: theme.Rgb = if (term.colors.foreground.get()) |c|
        .fromVt(c)
    else
        theme.fg();

    const layout = pangocairo.createLayout(cr);
    defer layout.unref();
    layout.setFontDescription(self.font);

    const bounds: ?SelectionBounds = bounds: {
        const sel = screen.selection orelse break :bounds null;
        const tl = screen.pages.pointFromPin(.screen, sel.topLeft(screen)) orelse
            break :bounds null;
        const br = screen.pages.pointFromPin(.screen, sel.bottomRight(screen)) orelse
            break :bounds null;
        break :bounds .{
            .tl = tl.screen,
            .br = br.screen,
            .rectangle = sel.rectangle,
        };
    };

    var y: u16 = 0;
    while (y < term.rows) : (y += 1) {
        const pin = screen.pages.pin(.{ .viewport = .{ .x = 0, .y = y } }) orelse continue;
        const cells = pin.cells(.all);
        const row_top = pad + @as(f64, @floatFromInt(y)) * self.cell_h;

        const span: ?[2]usize = if (bounds) |b| span: {
            const p = screen.pages.pointFromPin(.screen, pin) orelse break :span null;
            break :span b.span(p.screen.y, cells.len);
        } else null;

        // Pass 1: backgrounds. Drawn as one rect per run so that a wide
        // block of color doesn't turn into hundreds of tiny fills.
        var x: usize = 0;
        while (x < cells.len) {
            const start_bg = styled(pin, &cells[x], term, default_fg, default_bg, inSpan(span, x)).bg;
            var end = x + 1;
            while (end < cells.len) : (end += 1) {
                const next = styled(pin, &cells[end], term, default_fg, default_bg, inSpan(span, end)).bg;
                if (!std.meta.eql(start_bg, next)) break;
            }

            if (start_bg) |color| {
                const r, const g, const b = color.cairoRgb();
                cr.setSourceRgb(r, g, b);
                cr.rectangle(
                    pad + @as(f64, @floatFromInt(x)) * self.cell_w,
                    row_top,
                    @as(f64, @floatFromInt(end - x)) * self.cell_w,
                    self.cell_h,
                );
                cr.fill();
            }

            x = end;
        }

        // Pass 2: text runs.
        x = 0;
        while (x < cells.len) {
            if (cells[x].wide == .spacer_tail) {
                x += 1;
                continue;
            }

            const look = styled(pin, &cells[x], term, default_fg, default_bg, inSpan(span, x));

            self.run_buf.clearRetainingCapacity();
            const run_start = x;
            while (x < cells.len) : (x += 1) {
                const cell = &cells[x];
                if (cell.wide == .spacer_tail) continue;

                const cell_look = styled(pin, cell, term, default_fg, default_bg, inSpan(span, x));
                if (x != run_start and !look.sameRun(cell_look)) break;

                try self.appendCell(pin, cell);
            }

            if (self.run_buf.items.len > 0) {
                try self.drawRun(
                    cr,
                    layout,
                    look,
                    pad + @as(f64, @floatFromInt(run_start)) * self.cell_w,
                    row_top,
                );
            }
        }
    }

    self.drawCursor(cr, layout, term, default_bg);
}

/// Append a cell's text to the current run.
fn appendCell(self: *Terminal, pin: vt.Pin, cell: *const vt.Cell) !void {
    switch (cell.content_tag) {
        .codepoint, .codepoint_grapheme => {
            const cp = cell.content.codepoint.data;
            // An empty cell still occupies a column, so emit a space to
            // keep the run's characters aligned to the grid.
            try self.appendCodepoint(if (cp == 0) ' ' else cp);

            if (cell.content_tag == .codepoint_grapheme) {
                if (pin.grapheme(cell)) |extra| {
                    for (extra) |cp2| try self.appendCodepoint(cp2);
                }
            }
        },
        // Background-only cells have no text.
        .bg_color_palette, .bg_color_rgb => try self.appendCodepoint(' '),
    }
}

fn appendCodepoint(self: *Terminal, cp: u21) !void {
    var buf: [4]u8 = undefined;
    const n = std.unicode.utf8Encode(cp, &buf) catch return;
    try self.run_buf.appendSlice(self.alloc, buf[0..n]);
}

fn drawRun(
    self: *Terminal,
    cr: *cairo.Context,
    layout: *pango.Layout,
    look: Appearance,
    x: f64,
    y: f64,
) !void {
    self.font.setWeight(if (look.bold) .bold else .normal);
    self.font.setStyle(if (look.italic) .italic else .normal);
    layout.setFontDescription(self.font);

    // Pango wants a NUL-terminated pointer even though we pass the length.
    try self.run_buf.append(self.alloc, 0);
    const text = self.run_buf.items[0 .. self.run_buf.items.len - 1 :0];
    layout.setText(text.ptr, @intCast(text.len));

    const r, const g, const b = look.fg.cairoRgb();
    cr.setSourceRgb(r, g, b);
    cr.moveTo(x, y);
    pangocairo.showLayout(cr, layout);

    // Pango has no notion of our grid, so decorations are drawn by hand
    // across the exact width of the run.
    const run_w = runWidth(layout);
    if (look.underline) {
        cr.rectangle(x, y + self.ascent + 2, run_w, 1);
        cr.fill();
    }
    if (look.strikethrough) {
        cr.rectangle(x, y + self.ascent * 0.6, run_w, 1);
        cr.fill();
    }
}

fn runWidth(layout: *pango.Layout) f64 {
    var w: c_int = 0;
    var h: c_int = 0;
    layout.getPixelSize(&w, &h);
    return @floatFromInt(w);
}

fn drawCursor(
    self: *Terminal,
    cr: *cairo.Context,
    layout: *pango.Layout,
    term: *vt.Terminal,
    default_bg: theme.Rgb,
) void {
    // Only show the cursor when we're looking at the live screen; while
    // scrolled back into history there is nothing meaningful to point at.
    if (term.screens.active.pages.viewport != .active) return;
    if (!term.modes.get(.cursor_visible)) return;

    const cursor = term.screens.active.cursor;
    if (cursor.x >= term.cols or cursor.y >= term.rows) return;

    const x = pad + @as(f64, @floatFromInt(cursor.x)) * self.cell_w;
    const y = pad + @as(f64, @floatFromInt(cursor.y)) * self.cell_h;

    const color: theme.Rgb = if (term.colors.cursor.get()) |c| .fromVt(c) else theme.cursor();
    const r, const g, const b = color.cairoRgb();
    cr.setSourceRgb(r, g, b);

    switch (cursor.cursor_style) {
        .block => {
            cr.rectangle(x, y, self.cell_w, self.cell_h);
            cr.fill();

            // Redraw the covered character in the background color so it
            // stays legible through the block.
            const pin = term.screens.active.pages.pin(.{
                .viewport = .{ .x = cursor.x, .y = cursor.y },
            }) orelse return;
            const cell = pin.rowAndCell().cell;
            if (cell.content_tag != .codepoint and cell.content_tag != .codepoint_grapheme) return;
            const cp = cell.content.codepoint.data;
            if (cp == 0 or cp == ' ') return;

            var buf: [5]u8 = @splat(0);
            const n = std.unicode.utf8Encode(cp, buf[0..4]) catch return;
            layout.setText(buf[0..n :0].ptr, @intCast(n));

            const tr, const tg, const tb = default_bg.cairoRgb();
            cr.setSourceRgb(tr, tg, tb);
            cr.moveTo(x, y);
            pangocairo.showLayout(cr, layout);
        },
        .bar => {
            cr.rectangle(x, y, 2, self.cell_h);
            cr.fill();
        },
        .underline => {
            cr.rectangle(x, y + self.cell_h - 2, self.cell_w, 2);
            cr.fill();
        },
        .block_hollow => {
            cr.rectangle(x + 0.5, y + 0.5, self.cell_w - 1, self.cell_h - 1);
            cr.setLineWidth(1);
            cr.stroke();
        },
    }
}

/// Resolve a cell's style into concrete colors and attributes.
fn appearance(
    pin: vt.Pin,
    cell: *const vt.Cell,
    term: *vt.Terminal,
    default_fg: theme.Rgb,
    default_bg: theme.Rgb,
) Appearance {
    const palette = &term.colors.palette.current;

    // Cells that carry only a background color have no style entry.
    switch (cell.content_tag) {
        .bg_color_palette => return .{
            .fg = default_fg,
            .bg = .fromVt(palette[cell.content.color_palette.data]),
            .bold = false,
            .italic = false,
            .underline = false,
            .strikethrough = false,
        },
        .bg_color_rgb => {
            const c = cell.content.color_rgb;
            return .{
                .fg = default_fg,
                .bg = .{ .r = c.r, .g = c.g, .b = c.b },
                .bold = false,
                .italic = false,
                .underline = false,
                .strikethrough = false,
            };
        },
        else => {},
    }

    const style = pin.style(cell);

    var fg: theme.Rgb = switch (style.fg_color) {
        .none => default_fg,
        .palette => |i| brightIfBold(palette, i, style.flags.bold),
        .rgb => |c| .fromVt(c),
    };
    var bg: ?theme.Rgb = switch (style.bg_color) {
        .none => null,
        .palette => |i| .fromVt(palette[i]),
        .rgb => |c| .fromVt(c),
    };

    if (style.flags.inverse) {
        const new_fg = bg orelse default_bg;
        const new_bg = fg;
        fg = new_fg;
        bg = new_bg;
    }

    if (style.flags.invisible) fg = bg orelse default_bg;

    return .{
        .fg = fg,
        .bg = bg,
        .bold = style.flags.bold,
        .italic = style.flags.italic,
        .underline = style.flags.underline != .none,
        .strikethrough = style.flags.strikethrough,
    };
}

/// Bold text using one of the low 8 palette colors conventionally renders
/// with the matching bright color.
fn brightIfBold(palette: *const [256]vt.color.RGB, index: u8, bold: bool) theme.Rgb {
    const effective = if (bold and index < 8) index + 8 else index;
    return .fromVt(palette[effective]);
}