path: root/src/ninep/cols.zig

//! The layout and the header tags: /layout, /tag (the workspace's) and
//! /col/<serial>/tag (each column's; a column's serial stays while it lives,
//! as a pane's does). acme serves no column files -- its columns
//! are only a window's place -- so these go past it: a script can see where
//! the panes are and edit the tags a person clicks in.
const std = @import("std");
const pardes = @import("../pardes.zig");
const Pardes = pardes.Pardes;
const tree = @import("tree.zig");
const limits = @import("../memory.zig").limits;
const tagline = pardes.tagline;
const layout = pardes.layout;
const Text = pardes.panes.Text;
const Req = tree.Req;
const Reply = tree.Reply;
const E = tree.E;

/// The column with the keyboard: the header's, when a column tag has it,
/// else the active pane's. Null when the workspace tag has it and no pane
/// is active.
pub fn activeColumn(p: *const Pardes) ?usize {
    if (p.header_focus) if (p.header_column) |c| return if (c < p.ncol) c else null;
    const at = layout.findPane(p, p.active) orelse return null;
    return at.col;
}

/// One line a column: its serial (the name /col/<serial> and the log give
/// it, which stays while it lives), its index left to right, x and width in
/// cells, `current` or `notcurrent` (rio's words, for the column with the
/// keyboard), `empty` or `full`, and its panes' serials, top to bottom;
/// then `active <serial>`: the active column, where pane/new and a look
/// place a pane next (acme's activecol), not always the keyboard's.
pub fn writeLayout(p: *Pardes, w: *std.Io.Writer) !void {
    const active = activeColumn(p);
    for (0..p.ncol) |c| {
        try w.print("{d} {d} {d} {d} {s} {s}", .{
            layout.columnSerial(p, c),                    c,                                          p.col_x[c], p.col_w[c],
            if (active == c) "current" else "notcurrent", if (p.col_n[c] == 0) "empty" else "full",
        });
        for (p.col_panes[c][0..p.col_n[c]]) |id| if (p.panes[id]) |pane| try w.print(" {d}", .{pane.serial});
        try w.writeByte('\n');
    }
    if (p.activeColumn() orelse active) |c| try w.print("active {d}\n", .{layout.columnSerial(p, c)}) else try w.writeAll("active -\n");
}

/// A header by its node: the workspace's (`serial` null) or the column's
/// with that serial; null when that column has closed.
const Header = struct { text: *Text, col: ?usize };

fn header(p: *Pardes, serial: ?u32) ?Header {
    const s = serial orelse return .{ .text = &p.global_tag, .col = null };
    const c = layout.columnBySerial(p, s) orelse return null;
    return .{ .text = &p.col_tags[c], .col = c };
}

pub fn headerText(p: *Pardes, serial: ?u32) ?[]const u8 {
    const h = header(p, serial) orelse return null;
    return if (h.col) |c| tagline.columnTag(p, c) else tagline.topbar(p);
}

pub fn read(p: *Pardes, req: Req, serial: ?u32) Reply {
    applyTruncation(p, serial);
    const text = headerText(p, serial) orelse return Reply.fail(req.tag, E.NOENT);
    const out = p.fs.stage(p.gpa);
    // As a pane tag reads: the text alone, no newline after it.
    out.appendSlice(p.gpa, text) catch return Reply.fail(req.tag, E.NOMEM);
    return tree.stagedReply(p, req);
}

/// A write appends, as a pane tag's does; the tag is one line, so a newline
/// in it becomes a space (tagline.flattenHeaders), but after a truncation
/// the newline that ends the write is dropped, as a pane tag drops it.
pub fn write(p: *Pardes, req: Req, serial: ?u32) Reply {
    const t = (header(p, serial) orelse return Reply.fail(req.tag, E.NOENT)).text;
    if (req.data.len == 0) return .{ .tag = req.tag, .written = 0 };
    const pending = p.fs.header_trunc_pending == rewriteKey(serial);
    // The same checks as a pane tag's, whole or not at all; a refused
    // write drops the truncation it would have come with.
    if (pardes.ctlfs.pane.tagFault(req.data)) |why| {
        if (pending) p.fs.header_trunc_pending = null;
        return tree.failText(req.tag, E.INVAL, why);
    }
    const had = if (pending) 0 else headerText(p, serial).?.len;
    // A rewrite drops its one trailing newline: `echo <4096 bytes> > tag`
    // is 4096 bytes of tag, and fits.
    const rewrite = pending or p.fs.header_rewrite == rewriteKey(serial);
    const counted = req.data.len - @intFromBool(rewrite and req.data[req.data.len - 1] == '\n');
    if (counted > limits.max_tag_tail -| had) {
        if (pending) p.fs.header_trunc_pending = null;
        return tree.failText(req.tag, E.NOSPC, pardes.ctlfs.pane.e_tag_over);
    }
    applyTruncation(p, serial);
    const was = headerText(p, serial).?;
    var data = req.data;
    const rewriting = p.fs.header_rewrite == rewriteKey(serial);
    // A newline held from the write before goes in once more text follows.
    const held: []const u8 = if (rewriting and p.fs.header_held) " " else "";
    p.fs.header_held = false;
    if (rewriting and data[data.len - 1] == '\n') {
        data = data[0 .. data.len - 1];
        p.fs.header_held = true;
    }
    const next = std.mem.concat(p.gpa, u8, &.{ was, held, data }) catch return Reply.fail(req.tag, E.NOMEM);
    std.mem.replaceScalar(u8, next, '\n', ' ');
    if (t.own) |own| p.gpa.free(own);
    t.own = next;
    return .{ .tag = req.tag, .written = @intCast(req.data.len) };
}

/// Truncating clears it, as a pane tag's `cleartag`: its default words go
/// too, and `u` in it brings them back.
pub fn truncate(p: *Pardes, serial: ?u32) tree.Status {
    if (header(p, serial) == null) return .err;
    // Done with the write after it, which may yet be refused.
    p.fs.header_trunc_pending = rewriteKey(serial);
    return .ok;
}

/// A pending truncation of this header, done.
pub fn applyTruncation(p: *Pardes, serial: ?u32) void {
    if (p.fs.header_trunc_pending != rewriteKey(serial)) return;
    p.fs.header_trunc_pending = null;
    _ = clear(p, serial);
}

fn clear(p: *Pardes, serial: ?u32) tree.Status {
    const t = (header(p, serial) orelse return .err).text;
    const empty = p.gpa.alloc(u8, 0) catch return .err;
    t.remember(p.gpa, if (t.own) |own| .{ .text = own } else null);
    if (t.own) |own| p.gpa.free(own);
    t.own = empty;
    t.cur_row = 0;
    t.cur_col = 0;
    p.fs.header_rewrite = rewriteKey(serial);
    p.fs.header_held = false;
    return .ok;
}

/// Which header a truncation was of: the workspace's is 0 (no column's
/// serial is), a column's its serial.
fn rewriteKey(serial: ?u32) u32 {
    return serial orelse 0;
}

pub fn released(p: *Pardes, serial: ?u32) void {
    applyTruncation(p, serial);
    if (p.fs.header_rewrite != rewriteKey(serial)) return;
    p.fs.header_rewrite = null;
    p.fs.header_held = false;
}

/// A column's ctl: the words that act on a column, as its tag's clicks do --
/// Delcol, Joincol, New, Tty -- one a line, each run as from that tag. What
/// they say is the session's in the log (`msg -`), not the focused pane's.
pub fn writeCtl(p: *Pardes, req: Req, serial: u32) Reply {
    // What this write touched, alone, reads back (runBuiltin notes it).
    p.fs.results_len = 0;
    p.fs.session_write = true;
    defer p.fs.session_write = false;
    var lines = std.mem.splitScalar(u8, req.data, '\n');
    while (lines.next()) |raw| {
        const line = std.mem.trim(u8, raw, " \t\r");
        if (line.len == 0 or pardes.exec.isComment(line)) continue;
        const word = line[0 .. std.mem.indexOfAny(u8, line, " \t") orelse line.len];
        const takes = for ([_][]const u8{ "Delcol", "Joincol", "New", "Tty" }) |w| {
            if (std.mem.eql(u8, w, word)) break true;
        } else false;
        // Plan 9's words for it, so a mount's errno is EINVAL as the root's
        // and a pane's ctl give (9ns reads "control message").
        if (!takes) return tree.failText(req.tag, E.INVAL, std.fmt.bufPrint(&p.fs.ename, "unknown control message \"{s}\": a column's ctl takes Delcol, Joincol, New or Tty", .{pardes.ctlfs.ctl.firstWord(line)[0..@min(pardes.ctlfs.ctl.firstWord(line).len, 64)]}) catch "unknown control message");
        // Only Tty takes a word (its shell); `New extra` is no New.
        if (!std.mem.eql(u8, word, "Tty") and word.len != line.len)
            return tree.failText(req.tag, E.INVAL, std.fmt.bufPrint(&p.fs.ename, "wrong #args in control message \"{s}\"", .{pardes.ctlfs.ctl.firstWord(line)[0..@min(pardes.ctlfs.ctl.firstWord(line).len, 64)]}) catch "wrong #args in control message");
        const col = layout.columnBySerial(p, serial) orelse return Reply.fail(req.tag, E.NOENT);
        p.exec_column = col;
        defer p.exec_column = null;
        p.exec_header = true;
        defer p.exec_header = false;
        if (pardes.ctlfs.ctl.runBuiltin(p, req, p.active, line)) |refusal| return refusal;
    }
    return .{ .tag = req.tag, .written = @intCast(req.data.len) };
}

/// A column's exec (`serial`), or the workspace tag's (/tagexec, null):
/// each line run as a middle click on it in that tag, a column's acting on
/// that column. A read answers the panes the last write touched, as /exec's
/// does; what the words say is the session's in the log (`msg -`).
pub fn writeExec(p: *Pardes, req: Req, serial: ?u32) Reply {
    p.fs.results_len = 0;
    p.fs.session_write = true;
    defer p.fs.session_write = false;
    var lines = std.mem.splitScalar(u8, req.data, '\n');
    while (lines.next()) |raw| {
        const line = std.mem.trim(u8, raw, " \t\r");
        if (line.len == 0) continue;
        for (line) |c| if ((c < ' ' and c != '\t') or c == 0x7f) return tree.failText(req.tag, E.INVAL, pardes.ctlfs.ctl.e_control);
        if (pardes.ctlfs.ctl.tooLong(req, line)) |refusal| return refusal;
        // A pane's word (Undo, Msg, Save) is no word of a tag no pane owns:
        // refused as the root's ctl refuses it, never done at whichever
        // pane has the keyboard. The tag's own words (New, Tty, Find, Grep
        // in a column's) are its to run.
        if (paneWord(line, if (serial == null) pardes.config.topbar_str else tagline.column_tag_default))
            return pardes.ctlfs.ctl.refuseTo(p, req, "not a session control message", line, "pane/<n>/ctl");
        const col = if (serial) |s| layout.columnBySerial(p, s) orelse return Reply.fail(req.tag, E.NOENT) else null;
        // With no pane at all, a word runs at the stand-in, as a click in
        // the empty window's tag does (runBuiltinFrom).
        p.exec_column = col;
        defer p.exec_column = null;
        p.exec_header = true;
        defer p.exec_header = false;
        if (pardes.ctlfs.ctl.captured(p, req, p.active, true, line, true)) |refusal| return refusal;
    }
    return .{ .tag = req.tag, .written = @intCast(req.data.len) };
}

test "New written to a column's exec makes its scratch in the session's directory, as tagexec's does" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const session = "/project/src";
    @memcpy(p.session_dir[0..session.len], session);
    p.session_dir_len = session.len;
    const serial = layout.columnSerial(p, 0);
    const exec_node = tree.Node.ofCol(serial, .exec);
    try testing.expectEqual(tree.Status.ok, th.wr(p, exec_node, "New\n").reply.status);
    try testing.expectEqualStrings("/project/src/+New", p.panes[p.active].?.file.?.path);
}

test "Joincol is refused when the joined column cannot give each pane its tag and 2 rows" {
    const p = try pardes.Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 12 });
    defer p.deinit();
    while (p.nextEffect()) |_| {}
    const ctl = @intFromEnum(tree.TopFile.ctl);
    const focus = @intFromEnum(tree.TopFile.focus);
    // Two panes in the first column, then a second column of two.
    const a = try th.newPane(p);
    _ = a;
    try testing.expectEqual(tree.Status.ok, th.wr(p, ctl, "Newcol\n").reply.status);
    const b = try th.newPane(p);
    var digits: [16]u8 = undefined;
    _ = th.wr(p, focus, try std.fmt.bufPrint(&digits, "{d}\n", .{b}));
    _ = try th.newPane(p);
    try testing.expectEqual(@as(usize, 2), p.ncol);
    try testing.expect(p.col_n[0] >= 2 and p.col_n[1] >= 2);
    // Focus in the left column: joined, four panes want 12 rows of 10.
    const left = p.panes[p.col_panes[0][0]].?.serial;
    _ = th.wr(p, focus, try std.fmt.bufPrint(&digits, "{d}\n", .{left}));
    const r = th.wr(p, ctl, "Joincol\n");
    try testing.expectEqual(tree.Status.err, r.reply.status);
    try testing.expect(std.mem.indexOf(u8, r.reply.ename, "tag and 2 rows") != null);
    try testing.expectEqual(@as(usize, 2), p.ncol);
    try testing.expect(pardes.layout.minimaFit(p));
}

test "pane/new takes rows from a pane in another column before refusing ENOSPC" {
    const p = try pardes.Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 16 });
    defer p.deinit();
    while (p.nextEffect()) |_| {}
    const first = p.panes[p.active].?.serial;
    // A second column holding one tall pane.
    try testing.expectEqual(tree.Status.ok, th.wr(p, @intFromEnum(tree.TopFile.ctl), "Newcol\n").reply.status);
    const tall = try th.newPane(p);
    const tall_col = layout.findPane(p, p.paneBySerial(tall).?).?.col;
    const focus = @intFromEnum(tree.TopFile.focus);
    var digits: [16]u8 = undefined;
    // From the first column, until pane/new is refused.
    var moved = false;
    for (0..pardes.MAX_PANES) |_| {
        _ = th.wr(p, focus, try std.fmt.bufPrint(&digits, "{d}\n", .{first}));
        const made = th.newPane(p) catch break;
        if (layout.findPane(p, p.paneBySerial(made).?).?.col == tall_col) moved = true;
    }
    try testing.expect(moved);
}

test "in a > cut into several tag writes, those taken before a refused one stand" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const node = tree.Node.of(th.serialOf(p), .tag);
    _ = th.call(p, .{ .tag = 1, .op = .setattr, .node = node, .truncate = true });
    const h = th.call(p, .{ .tag = 2, .op = .open, .node = node, .omode = 1 }).reply.handle;
    try testing.expectEqual(tree.Status.ok, th.call(p, .{ .tag = 3, .op = .write, .node = node, .handle = h, .data = "Make" }).reply.status);
    try testing.expectEqual(E.INVAL, th.call(p, .{ .tag = 4, .op = .write, .node = node, .handle = h, .data = " \x01" }).errno());
    _ = th.call(p, .{ .tag = 5, .op = .release, .node = node, .handle = h, .opened = true });
    try testing.expect(std.mem.endsWith(u8, th.rd(p, node, 0, 4096).bytes, "Make"));
}

test "exactly 4096 bytes written with echo's newline after a truncation fit every kind of tag" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const serial = th.serialOf(p);
    const text = "w" ** 4096 ++ "\n";
    for ([_]u64{ tree.Node.of(serial, .tag), tree.Node.ofCol(layout.columnSerial(p, 0), .tag), @intFromEnum(tree.TopFile.tag) }) |node| {
        _ = th.call(p, .{ .tag = 1, .op = .setattr, .node = node, .truncate = true });
        const h = th.call(p, .{ .tag = 2, .op = .open, .node = node, .omode = 1 }).reply.handle;
        const r = th.call(p, .{ .tag = 3, .op = .write, .node = node, .handle = h, .data = text });
        try testing.expectEqual(tree.Status.ok, r.reply.status);
        _ = th.call(p, .{ .tag = 4, .op = .release, .node = node, .handle = h, .opened = true });
        try testing.expect(std.mem.endsWith(u8, th.rd(p, node, 0, 1 << 16).bytes, "w" ** 4096));
        // One more byte is over.
        _ = th.call(p, .{ .tag = 5, .op = .setattr, .node = node, .truncate = true });
        const h2 = th.call(p, .{ .tag = 6, .op = .open, .node = node, .omode = 1 }).reply.handle;
        try testing.expectEqual(E.NOSPC, th.call(p, .{ .tag = 7, .op = .write, .node = node, .handle = h2, .data = "w" ** 4097 ++ "\n" }).errno());
        _ = th.call(p, .{ .tag = 8, .op = .release, .node = node, .handle = h2, .opened = true });
    }
}

test "a Newcol refused because the tags would not fit logs its err alone and spends no column serial" {
    const p = try pardes.Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 14 });
    defer p.deinit();
    while (p.nextEffect()) |_| {}
    // Long tags wrap onto more rows as their column narrows: the boot's
    // two panes share one, and each keeps its tag and two rows.
    const made = try th.newPane(p);
    const pane = p.panes[p.paneBySerial(made).?].?;
    const col = layout.findPane(p, p.paneBySerial(made).?).?.col;
    for (p.col_panes[col][0..p.col_n[col]]) |k| {
        const each = p.panes[k].?;
        if (each.tag.own) |old| p.gpa.free(old);
        each.tag.own = try p.gpa.dupe(u8, "word " ** 60);
    }
    try testing.expect(p.col_n[col] >= 2);
    p.sync();
    const ctl = @intFromEnum(tree.TopFile.ctl);
    const focus = @intFromEnum(tree.TopFile.focus);
    var digits: [16]u8 = undefined;
    const own = try std.fmt.bufPrint(&digits, "{d}\n", .{pane.serial});
    var refused = false;
    for (0..pardes.MAX_COLS) |_| {
        // From the long tag's column, so it is the one split narrower.
        _ = th.wr(p, focus, own);
        const serial_before = p.next_column_serial;
        const log_before = try pardes.ctlfs.events.freezeLog(p);
        defer p.gpa.free(log_before.bytes);
        const r = th.wr(p, ctl, "Newcol\n");
        if (r.reply.status == .ok) continue;
        if (std.mem.indexOf(u8, r.reply.ename, "tags would not fit") == null) continue;
        refused = true;
        try testing.expectEqual(serial_before, p.next_column_serial);
        const log_after = try pardes.ctlfs.events.freezeLog(p);
        defer p.gpa.free(log_after.bytes);
        const added = log_after.bytes[log_before.bytes.len..];
        try testing.expect(std.mem.startsWith(u8, added, "err "));
        try testing.expectEqual(@as(usize, 1), std.mem.count(u8, added, "\n"));
        break;
    }
    try testing.expect(refused);
}

test "a tagexec word that makes, acts on and focuses no pane reads back nothing" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const tagexec = @intFromEnum(tree.TopFile.tagexec);
    try testing.expectEqual(tree.Status.ok, th.wr(p, tagexec, "Newcol\n").reply.status);
    try testing.expectEqualStrings("", th.rd(p, tagexec, 0, 64).bytes);
    // A column's New makes one, and answers it.
    const col_exec = tree.Node.ofCol(layout.columnSerial(p, 0), .exec);
    try testing.expectEqual(tree.Status.ok, th.wr(p, col_exec, "New\n").reply.status);
    var want: [16]u8 = undefined;
    try testing.expectEqualStrings(try std.fmt.bufPrint(&want, "{d}\n", .{p.panes[p.active].?.serial}), th.rd(p, col_exec, 0, 64).bytes);
}

test "New written to a column's ctl reads back the new pane alone, as its exec does" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const root_exec = @intFromEnum(tree.TopFile.exec);
    _ = th.wr(p, root_exec, "Msg before\n");
    const ctl_node = tree.Node.ofCol(layout.columnSerial(p, 0), .ctl);
    try testing.expectEqual(tree.Status.ok, th.wr(p, ctl_node, "New\n").reply.status);
    var want: [16]u8 = undefined;
    try testing.expectEqualStrings(try std.fmt.bufPrint(&want, "{d}\n", .{p.panes[p.active].?.serial}), th.rd(p, root_exec, 0, 64).bytes);
}

/// Whether `line` names a builtin that acts on a pane (every one of pane
/// scope, Edit too, which the root's ctl takes at the active pane) and is
/// not one of `own`, the words its tag holds by default: those a tag no
/// pane owns refuses, never doing them at the pane with the keyboard.
fn paneWord(line: []const u8, own: []const u8) bool {
    const cmd = pardes.exec.commandText(line);
    const word = cmd[0 .. std.mem.indexOfAny(u8, cmd, " \t+") orelse cmd.len];
    const b = std.meta.stringToEnum(pardes.builtins.registry.Builtin(), word) orelse return false;
    if (pardes.builtins.registry.scope(b) == .session) return false;
    // A new pane is every tag's to make, in the session's directory.
    if (b == .New or b == .Tty) return false;
    var words = std.mem.tokenizeScalar(u8, own, ' ');
    while (words.next()) |w| if (std.mem.eql(u8, w, word)) return false;
    return true;
}

test "a pane's word written to /tagexec or a column's exec is refused, and acts on no pane" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const col_exec = tree.Node.ofCol(layout.columnSerial(p, 0), .exec);
    for ([_]u64{ @intFromEnum(tree.TopFile.tagexec), col_exec }) |node| {
        for ([_][]const u8{ "Undo\n", "Msg hi\n", "Redo\n" }) |line| {
            const refused = th.wr(p, node, line);
            try testing.expectEqual(E.INVAL, refused.errno());
            try testing.expectStringStartsWith(refused.reply.ename, "not a session control message");
        }
    }
    // The column tag's own words still run there.
    try testing.expectEqual(tree.Status.ok, th.wr(p, col_exec, "New\n").reply.status);
}

test "Help and Find at /tagexec act in the session's directory, not the keyboard pane's" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    var tmp = testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.writeFile(testing.io, .{ .sub_path = "needle.txt", .data = "n\n" });
    var buf: [4096]u8 = undefined;
    const session = buf[0..try tmp.dir.realPath(testing.io, &buf)];
    @memcpy(p.session_dir[0..session.len], session);
    p.session_dir_len = @intCast(session.len);
    const tagexec = @intFromEnum(tree.TopFile.tagexec);
    for ([_][]const u8{ "Help\n", "Find needle\n" }) |line| {
        try testing.expectEqual(tree.Status.ok, th.wr(p, tagexec, line).reply.status);
        const made = p.panes[p.active].?.file.?.path;
        try testing.expectEqualStrings(session, std.fs.path.dirname(made).?);
    }
}

test "a shell command at /tagexec or a column's exec is a command pane in the session's directory, never typed into the keyboard's terminal" {
    if (comptime !pardes.hosted) return;
    const p = try Pardes.init(testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 30 });
    defer p.deinit();
    while (p.nextEffect()) |_| {}
    const term = p.panes[p.active].?;
    try testing.expect(pardes.exec.takesCommandLine(p, p.active));
    const col_exec = tree.Node.ofCol(layout.columnSerial(p, 0), .exec);
    for ([_]u64{ @intFromEnum(tree.TopFile.tagexec), col_exec }) |node| {
        p.active = p.paneBySerial(term.serial).?;
        const before = p.next_serial;
        const r = th.wr(p, node, "echo from-the-tag\n");
        try testing.expectEqual(tree.Status.ok, r.reply.status);
        try testing.expectEqualStrings("", r.pty());
        try testing.expectEqual(before + 1, p.next_serial);
        const made = p.panes[p.paneBySerial(p.next_serial).?].?; // the newest
        try testing.expectEqualStrings("echo from-the-tag", made.command.?);
        try testing.expectEqualStrings(p.sessionDir(), made.cwdSlice());
    }
}

test "New and Tty run at /tagexec and a column's exec, with no pane at all too" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const tagexec = @intFromEnum(tree.TopFile.tagexec);
    const col_exec = tree.Node.ofCol(layout.columnSerial(p, 0), .exec);
    for ([_]u64{ tagexec, col_exec }) |node| for ([_][]const u8{ "New\n", "Tty\n" }) |line| {
        const before = p.next_serial;
        try testing.expectEqual(tree.Status.ok, th.wr(p, node, line).reply.status);
        try testing.expectEqual(before + 1, p.next_serial);
    };
    // Every pane gone: the workspace tag makes one all the same.
    for ([_][]const u8{ "New\n", "Tty\n" }) |line| {
        while (p.ncol > 0) {
            const first = p.panes[p.col_panes[0][0]].?.serial;
            _ = th.wr(p, tree.Node.of(first, .ctl), "delete\n");
            if (p.anyPane() == null) break;
        }
        try testing.expect(p.anyPane() == null);
        try testing.expectEqual(tree.Status.ok, th.wr(p, tagexec, line).reply.status);
        try testing.expect(p.anyPane() != null);
    }
}

test "every pane word a tag no pane owns does not hold is refused there, Edit included, and the pane is untouched" {
    const p = try th.withFile(testing.allocator, "keep me\n");
    defer p.deinit();
    const Builtin = pardes.builtins.registry.Builtin();
    const col_exec = tree.Node.ofCol(layout.columnSerial(p, 0), .exec);
    for ([_]struct { node: u64, own: []const u8 }{
        .{ .node = @intFromEnum(tree.TopFile.tagexec), .own = pardes.config.topbar_str },
        .{ .node = col_exec, .own = tagline.column_tag_default },
    }) |tag_file| {
        var checked: usize = 0;
        for (std.enums.values(Builtin)) |b| {
            if (pardes.builtins.registry.scope(b) == .session) continue;
            if (b == .New or b == .Tty) continue; // every tag's
            var owned = false;
            var words = std.mem.tokenizeScalar(u8, tag_file.own, ' ');
            while (words.next()) |w| owned = owned or std.mem.eql(u8, w, @tagName(b));
            if (owned) continue;
            var line: [64]u8 = undefined;
            const text = try std.fmt.bufPrint(&line, "{s}{s}\n", .{ @tagName(b), if (b == .Edit) " ,d" else if (pardes.builtins.registry.requiresArg(b)) " x" else "" });
            const refused = th.wr(p, tag_file.node, text);
            try testing.expectEqual(E.INVAL, refused.errno());
            try testing.expectStringStartsWith(refused.reply.ename, "not a session control message");
            checked += 1;
        }
        try testing.expect(checked > 20);
    }
    // `Edit ,d` wiped the pane with the keyboard: nothing touched it.
    try testing.expectEqualStrings("keep me\n", p.panes[0].?.file.?.content);
}

/// rmdir of a column closes it when it is empty; one with panes is
/// refused, saying so (close them, or Delcol on its ctl, which asks first).
pub fn remove(p: *Pardes, req: Req, serial: u32, file: tree.ColFile) Reply {
    if (file != .dir) return Reply.fail(req.tag, E.PERM);
    const col = layout.columnBySerial(p, serial) orelse return Reply.fail(req.tag, E.NOENT);
    if (p.col_n[col] > 0) return tree.failText(req.tag, E.NOTEMPTY, "column not empty: close its panes, or write Delcol to its ctl");
    p.removeColumn(col) catch return Reply.fail(req.tag, E.IO);
    return .{ .tag = req.tag };
}

// ---- tests ----

const testing = std.testing;
const th = @import("testing.zig");
const Node = tree.Node;

test "layout lists each column's place, panes and state, and the active one" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    p.newColumn(p.active);
    p.sync();
    const first_serial = layout.columnSerial(p, 0);
    const new_serial = layout.columnSerial(p, 1);
    try testing.expect(first_serial != new_serial);
    const layout_node = @intFromEnum(tree.TopFile.layout);
    const text = th.rd(p, layout_node, 0, 4096).bytes;
    var want: [256]u8 = undefined;
    const first = try std.fmt.bufPrint(&want, "{d} 0 {d} {d} notcurrent full {d}\n", .{ first_serial, p.col_x[0], p.col_w[0], p.panes[0].?.serial });
    try testing.expect(std.mem.startsWith(u8, text, first));
    // Newcol gives the new, empty column's tag the keyboard.
    try testing.expect(std.mem.indexOf(u8, text, "current empty\n") != null);
    try testing.expect(std.mem.endsWith(u8, text, try std.fmt.bufPrint(&want, "active {d}\n", .{new_serial})));
    try testing.expect(text.len > 0);
    try testing.expectEqual(@as(u64, 0), th.call(p, .{ .tag = 1, .op = .getattr, .node = layout_node }).reply.attr.size); // generated by each read
    // /index says which column each pane is in, by its serial, last.
    try testing.expect(std.mem.endsWith(u8, th.rd(p, @intFromEnum(tree.TopFile.index), 0, 4096).bytes, try std.fmt.bufPrint(&want, " {d}\n", .{first_serial})));
    try testing.expect(th.logHas(p, try std.fmt.bufPrint(&want, "newcol {d}\n", .{new_serial})));
    // A column that closes takes its name with it; the others keep theirs.
    try p.removeColumn(1);
    try testing.expect(th.logHas(p, try std.fmt.bufPrint(&want, "delcol {d}\n", .{new_serial})));
    try testing.expectEqual(E.NOENT, th.look_up(p, @intFromEnum(tree.TopFile.col), try std.fmt.bufPrint(&want, "{d}", .{new_serial})).errno());
    try testing.expectEqual(first_serial, layout.columnSerial(p, 0));
}

test "a column's tag and the workspace's read, replace and append as a pane tag does, on one line" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const col_dir = @intFromEnum(tree.TopFile.col);
    const serial = layout.columnSerial(p, 0);
    var name: [16]u8 = undefined;
    try testing.expectEqual(tree.Status.ok, th.look_up(p, col_dir, try std.fmt.bufPrint(&name, "{d}", .{serial})).reply.status);
    try testing.expectEqual(E.NOENT, th.look_up(p, col_dir, "0").errno());
    try testing.expectEqual(E.NOENT, th.look_up(p, col_dir, "777").errno());
    const tag = Node.ofCol(serial, .tag);
    try testing.expectEqual(tree.Status.ok, th.look_up(p, Node.ofCol(serial, .dir), "tag").reply.status);
    try testing.expectEqualStrings("New Tty Find Grep Joincol Delcol", th.rd(p, tag, 0, 4096).bytes);
    // `echo Make > tag`: cleared, then the newline ending the write dropped.
    _ = th.call(p, .{ .tag = 1, .op = .setattr, .node = tag, .truncate = true });
    _ = th.wr(p, tag, "Make\n");
    try testing.expectEqualStrings("Make", th.rd(p, tag, 0, 4096).bytes);
    _ = th.call(p, .{ .tag = 2, .op = .release, .node = tag });
    // `>>` appends; a newline in a one-line tag is a space.
    _ = th.wr(p, tag, " Lint\nNow");
    try testing.expectEqualStrings("Make Lint Now", th.rd(p, tag, 0, 4096).bytes);
    const top = @intFromEnum(tree.TopFile.tag);
    _ = th.call(p, .{ .tag = 3, .op = .setattr, .node = top, .truncate = true });
    _ = th.wr(p, top, "Newcol Exit\n");
    try testing.expectEqualStrings("Newcol Exit", tagline.topbar(p));
}

test "a focus write makes its pane's column the active one: layout says so and pane/new goes there" {
    for ([_][]const u8{ "Placement acme", "Placement pardes" }) |placement| {
        const p = try th.withFile(testing.allocator, "x\n");
        defer p.deinit();
        try testing.expect(p.executeBuiltinLine(p.active, placement));
        const left = p.panes[0].?.serial;
        p.newColumn(p.active);
        p.newScratchFor(p.active, .fs); // fills the new, right column
        p.sync();
        try testing.expectEqual(@as(usize, 1), layout.findPane(p, p.active).?.col);
        var digits: [16]u8 = undefined;
        _ = th.wr(p, @intFromEnum(tree.TopFile.focus), try std.fmt.bufPrint(&digits, "{d}\n", .{left}));
        var want: [32]u8 = undefined;
        const text = th.rd(p, @intFromEnum(tree.TopFile.layout), 0, 4096).bytes;
        try testing.expect(std.mem.endsWith(u8, text, try std.fmt.bufPrint(&want, "active {d}\n", .{layout.columnSerial(p, 0)})));
        const made = th.call(p, .{ .tag = 1, .op = .open, .node = @intFromEnum(tree.TopFile.new) }).reply.handle;
        try testing.expectEqual(@as(usize, 0), layout.findPane(p, p.paneBySerial(made).?).?.col);
    }
}

test "a refused write after a truncation leaves every kind of tag as it was, and Dump still works" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const serial = th.serialOf(p);
    const col = layout.columnSerial(p, 0);
    const big = "w" ** (limits.max_tag_tail + 1);
    // Each tag: a truncating open, then a write too long: nothing changes.
    for ([_]u64{ Node.of(serial, .tag), Node.ofCol(col, .tag), @intFromEnum(tree.TopFile.tag) }) |node| {
        _ = th.wr(p, node, " Mine");
        const before = try testing.allocator.dupe(u8, th.rd(p, node, 0, 1 << 16).bytes);
        defer testing.allocator.free(before);
        _ = th.call(p, .{ .tag = 1, .op = .setattr, .node = node, .truncate = true });
        const h = th.call(p, .{ .tag = 2, .op = .open, .node = node, .omode = 1 }).reply.handle;
        const r = th.call(p, .{ .tag = 3, .op = .write, .node = node, .handle = h, .data = big });
        try testing.expectEqual(E.NOSPC, r.errno());
        try testing.expectEqualStrings("no space: over 4096 bytes", r.reply.ename);
        // Its err record names the file once: `tag: no space`, never `tag: tag:`.
        try testing.expect(th.logHas(p, "tag: no space: over 4096 bytes"));
        try testing.expect(!th.logHas(p, "tag: tag:"));
        _ = th.call(p, .{ .tag = 4, .op = .release, .node = node, .handle = h, .opened = true });
        try testing.expectEqualStrings(before, th.rd(p, node, 0, 1 << 16).bytes);
        // A control character is refused the same way on every kind.
        try testing.expectEqual(E.INVAL, th.wr(p, node, "a\x01b").errno());
        // A truncation with no write after it clears at the close.
        _ = th.call(p, .{ .tag = 5, .op = .setattr, .node = node, .truncate = true });
        const e = th.call(p, .{ .tag = 6, .op = .open, .node = node, .omode = 1 }).reply.handle;
        _ = th.call(p, .{ .tag = 7, .op = .release, .node = node, .handle = e, .opened = true });
        try testing.expect(std.mem.indexOf(u8, th.rd(p, node, 0, 1 << 16).bytes, "Mine") == null);
    }
    try pardes.dump.dumpState(p);
}

test "a column's ctl and exec act on it as its tag would, and rmdir closes it only empty" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const first = layout.columnSerial(p, 0);
    p.newColumn(p.active);
    const empty = layout.columnSerial(p, 1);
    // New on the empty column's ctl fills it, wherever the keyboard is.
    try testing.expectEqual(tree.Status.ok, th.wr(p, Node.ofCol(empty, .ctl), "New\n").reply.status);
    try testing.expectEqual(@as(usize, 1), p.col_n[1]);
    try testing.expectEqual(E.INVAL, th.wr(p, Node.ofCol(empty, .ctl), "Exit\n").errno());
    var rec: [64]u8 = undefined;
    try testing.expect(th.logHas(p, try std.fmt.bufPrint(&rec, "err - col/{d}/ctl: unknown control message \"Exit\"", .{empty})));
    // rmdir refuses a column with a pane, and says why, in its error alone.
    const full = th.call(p, .{ .tag = 1, .op = .release, .node = Node.ofCol(empty, .dir), .remove = true });
    try testing.expectEqual(E.NOTEMPTY, full.errno());
    try testing.expect(std.mem.startsWith(u8, full.reply.ename, "column not empty"));
    try testing.expect(!th.logHas(p, try std.fmt.bufPrint(&rec, "err - col/{d}: column not empty", .{empty})));
    // exec runs a word as a click in that column's tag: Delcol closes it.
    try testing.expectEqual(tree.Status.ok, th.wr(p, Node.ofCol(empty, .exec), "Delcol\n").reply.status);
    try testing.expectEqual(@as(?usize, null), layout.columnBySerial(p, empty));
    // An empty column goes on rmdir.
    p.newColumn(p.active);
    const made = layout.columnSerial(p, 1);
    try testing.expectEqual(tree.Status.ok, th.call(p, .{ .tag = 2, .op = .release, .node = Node.ofCol(made, .dir), .remove = true }).reply.status);
    try testing.expectEqual(@as(?usize, null), layout.columnBySerial(p, made));
    try testing.expectEqual(first, layout.columnSerial(p, 0));
    // Joincol folds a column into the one on its right, which keeps its own
    // serial and tag.
    p.newColumn(p.active);
    const right = layout.columnSerial(p, 1);
    _ = th.wr(p, Node.ofCol(right, .tag), " Mine");
    try testing.expectEqual(tree.Status.ok, th.wr(p, Node.ofCol(first, .ctl), "Joincol\n").reply.status);
    try testing.expectEqual(@as(?usize, null), layout.columnBySerial(p, first));
    try testing.expectEqual(@as(?usize, 0), layout.columnBySerial(p, right));
    try testing.expect(std.mem.endsWith(u8, headerText(p, right).?, " Mine"));
    // The root's ctl points a column word at the column's own.
    try testing.expect(std.mem.endsWith(u8, th.wr(p, @intFromEnum(tree.TopFile.ctl), "Delcol\n").reply.ename, "write it to col/<serial>/ctl"));
}

test "tagexec runs a word as a click in the workspace tag; exec files read back what they touched; their messages are the session's" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const tagexec = @intFromEnum(tree.TopFile.tagexec);
    try testing.expectEqual(tree.Status.ok, th.look_up(p, tree.root, "tagexec").reply.status);
    try testing.expectEqual(tree.Status.ok, th.wr(p, tagexec, "Newcol\n").reply.status);
    try testing.expectEqual(@as(usize, 2), p.ncol);
    // Its announcement is the message row's, never logged; a pane's word
    // such as Msg is refused there.
    try testing.expect(!th.logHas(p, "msg - Newcol\n"));
    try testing.expectEqual(E.INVAL, th.wr(p, tagexec, "Msg from the top\n").errno());
    // A column's exec makes a pane there and reads it back.
    const right = layout.columnSerial(p, 1);
    try testing.expectEqual(tree.Status.ok, th.wr(p, Node.ofCol(right, .exec), "New\n").reply.status);
    const made = p.panes[p.col_panes[1][0]].?.serial;
    var want: [16]u8 = undefined;
    try testing.expectEqualStrings(try std.fmt.bufPrint(&want, "{d}\n", .{made}), th.rd(p, Node.ofCol(right, .exec), 0, 64).bytes);
    try testing.expectEqualStrings(try std.fmt.bufPrint(&want, "{d}\n", .{made}), th.rd(p, tagexec, 0, 64).bytes);
    try testing.expect(!th.logHas(p, "msg - New\n")); // announced on the message row only
}

test "a word run from the workspace's or a column's tag runs in the session's directory, a pane's in its own" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const session = p.sessionDir();
    try testing.expect(!std.mem.eql(u8, session, pardes.Pardes.paneDir(p.panes[0].?))); // the file is elsewhere
    const dirs = [_]u64{ @intFromEnum(tree.TopFile.tagexec), Node.ofCol(layout.columnSerial(p, 0), .exec) };
    for (dirs) |node| {
        try testing.expectEqual(tree.Status.ok, th.wr(p, node, "true\n").reply.status);
        const made = p.paneBySerial(p.fs.results[0]).?;
        try testing.expectEqualStrings(session, pardes.Pardes.paneDir(p.panes[made].?));
        try p.removePane(made, null);
    }
    const from_pane = p.panes[0].?.serial;
    _ = th.wr(p, Node.of(from_pane, .exec), "true\n");
    const made = p.paneBySerial(p.fs.results[0]).?;
    try testing.expectEqualStrings(pardes.Pardes.paneDir(p.panes[0].?), pardes.Pardes.paneDir(p.panes[made].?));
}

test "a command run from a column's tag gets its pane in that column, not the last" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    p.newColumn(p.active);
    p.newScratchFor(p.active, .fs); // fills the new, right column
    p.sync();
    const left = layout.columnSerial(p, 0);
    try testing.expectEqual(tree.Status.ok, th.wr(p, Node.ofCol(left, .exec), "true\n").reply.status);
    const made = p.paneBySerial(p.fs.results[0]).?;
    try testing.expectEqual(@as(usize, 0), layout.findPane(p, made).?.col);
    // Finished, it is reused only by its own column's commands.
    p.panes[made].?.command_done = true;
    p.panes[made].?.command_pty = false;
    try testing.expectEqual(tree.Status.ok, th.wr(p, Node.ofCol(layout.columnSerial(p, 1), .exec), "true\n").reply.status);
    const other = p.paneBySerial(p.fs.results[0]).?;
    try testing.expect(other != made);
    try testing.expectEqual(@as(usize, 1), layout.findPane(p, other).?.col);
}

test "a column's ctl refuses an unknown word and an argument as the other ctls do" {
    const p = try th.withFile(testing.allocator, "x\n");
    defer p.deinit();
    const ctl_node = Node.ofCol(layout.columnSerial(p, 0), .ctl);
    const unknown = th.wr(p, ctl_node, "Bogus\n");
    try testing.expectEqual(E.INVAL, unknown.errno());
    try testing.expect(std.mem.startsWith(u8, unknown.reply.ename, "unknown control message \"Bogus\""));
    const extra = th.wr(p, ctl_node, "New extra\n");
    try testing.expectEqual(E.INVAL, extra.errno());
    try testing.expect(std.mem.startsWith(u8, extra.reply.ename, "wrong #args"));
    try testing.expectEqual(@as(usize, 1), p.col_n[0]);
    // A pane's bare answer and a winsize of no size say what they take.
    try testing.expectEqualStrings("answer takes a choice or -", th.wr(p, Node.of(p.panes[0].?.serial, .ctl), "answer\n").reply.ename);
}