//! The layout and the header tags: /layout, /tag (the workspace's) and
//! /col/<n>/tag (each column's). 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 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 index, 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 <index>`.
pub fn writeLayout(p: *const Pardes, w: *std.Io.Writer) !void {
    const active = activeColumn(p);
    for (0..p.ncol) |c| {
        try w.print("{d} {d} {d} {s} {s}", .{
            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 (active) |c| try w.print("active {d}\n", .{c}) else try w.writeAll("active -\n");
}

pub fn layoutLen(p: *const Pardes) u64 {
    var buf: [256]u8 = undefined;
    var counting: std.Io.Writer.Discarding = .init(&buf);
    writeLayout(p, &counting.writer) catch return 0;
    return counting.fullCount();
}

/// The header a node names: the workspace's (`col` null) or a column's.
fn header(p: *Pardes, col: ?usize) ?*Text {
    const c = col orelse return &p.global_tag;
    return if (c < p.ncol) &p.col_tags[c] else null;
}

pub fn headerText(p: *Pardes, col: ?usize) ?[]const u8 {
    const c = col orelse return tagline.topbar(p);
    return if (c < p.ncol) tagline.columnTag(p, c) else null;
}

pub fn read(p: *Pardes, req: Req, col: ?usize) Reply {
    const text = headerText(p, col) orelse return Reply.fail(req.tag, E.NOENT);
    const out = p.fs.stage(p.gpa);
    out.appendSlice(p.gpa, text) catch return Reply.fail(req.tag, E.NOMEM);
    out.append(p.gpa, '\n') 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, col: ?usize) Reply {
    const t = header(p, col) orelse return Reply.fail(req.tag, E.NOENT);
    if (req.data.len == 0) return .{ .tag = req.tag, .written = 0 };
    const was = headerText(p, col).?;
    var data = req.data;
    const rewriting = p.fs.header_rewrite == rewriteKey(col);
    // 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, col: ?usize) tree.Status {
    const t = header(p, col) orelse return .err;
    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(col);
    p.fs.header_held = false;
    return .ok;
}

/// Which header a truncation was of: the workspace's is 0, a column's its
/// index + 1.
fn rewriteKey(col: ?usize) u32 {
    return if (col) |c| @intCast(c + 1) else 0;
}

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

// ---- 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 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, "0 {d} {d} notcurrent full {d}\n", .{ 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, "active 1\n"));
    try testing.expectEqual(@as(u64, text.len), th.call(p, .{ .tag = 1, .op = .getattr, .node = layout_node }).reply.attr.size);
    // /index says which column each pane is in, last.
    try testing.expect(std.mem.endsWith(u8, th.rd(p, @intFromEnum(tree.TopFile.index), 0, 4096).bytes, " 0\n"));
    try testing.expect(th.logHas(p, "newcol 1\n"));
}

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);
    try testing.expectEqual(tree.Status.ok, th.look_up(p, col_dir, "0").reply.status);
    try testing.expectEqual(E.NOENT, th.look_up(p, col_dir, "7").errno());
    const tag = Node.ofCol(0, .tag);
    try testing.expectEqual(tree.Status.ok, th.look_up(p, Node.ofCol(0, .dir), "tag").reply.status);
    try testing.expectEqualStrings("New Tty Find Grep Joincol Delcol\n", 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\n", 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\n", 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));
}