//! Everything the CLI prints.
//!
//! One function per output shape, each returning text plus whether that text is an
//! error, and none of them touching stdout: `main.zig` decides which stream a result
//! goes to and what the exit status is. These used to sit in `main.zig` alongside the
//! argument parsing, which left one file holding both ends of the program.
//!
//! Nothing here is shared with the TUI, and that is deliberate. The two frontends
//! want different things from the same engine results: this writes a full-width table
//! into an allocated buffer, while `src/tui/financial.zig` draws a windowed slice of
//! the same schedule into a surface at narrower widths. What they do share is the
//! engine's `Money` and `Number` rendering, so the figures themselves match.
//!
//! The `format` prefix these functions used to carry is now the file name, so
//! `format.conversion` and `format.amortization` read as what they are.

const std = @import("std");
const engine = @import("engine");

/// A finished piece of output: complete text, ending in a newline, and whether it is
/// an error. `main.zig` turns the flag into a stream and an exit status and prints the
/// text as it stands.
///
/// The newline is part of the text because some outputs are several lines and some
/// are one. It used to be split: errors and multi-line results carried their own,
/// single-line results relied on `main` to add one, and programmer mode did both, so
/// `tally -p 1` ended in a blank line.
pub const Result = struct {
    output: []const u8,
    is_error: bool,

    pub fn ok(output: []const u8) Result {
        return .{ .output = output, .is_error = false };
    }

    /// An engine error, in the engine's words.
    pub fn fail(err: engine.Error) Result {
        return .{ .output = decoratedError(err), .is_error = true };
    }

    /// Text that does not fit the buffer it was written into. One message for one
    /// condition: there used to be "buffer overflow" in eight places and "result too
    /// long to display" in a ninth, and the first reads like a security bug.
    const too_long: Result = .{ .output = "error: the result is too long to display\n", .is_error = true };
};

/// Which evaluator a CLI invocation wants.
///
/// The CLI's own concept, not the engine's: the engine has `evalString` and
/// `evalProgrammerString` and no notion of a mode. There are exactly two here
/// because `-p` is the only mode flag; the TUI's four tabs are its own enum.
pub const Mode = enum { standard, programmer };

/// How this frontend renders a number.
///
/// The engine has no default and no digit constants of its own: a terminal, a
/// clipboard and an Android screen want different budgets, so each frontend states
/// its own (NFR-9.9, "display precision is a separate decision from compute
/// precision"). These are the values the engine used to hold.
const display_format: engine.Number.FormatOptions = .{
    .fraction_digits = 20,
    .scientific_below_exponent = 15,
    .max_integer_digits = 40,
    .significant_digits = 17,
    .separators = true,
};

/// The engine's amount formatter, so the CLI, the TUI and the engine all group
/// amounts the same way. Two decimals and grouping are properties of money rather
/// than of a screen, so unlike `display_format` there is no budget to pass.
const money = engine.financial.money;

// -- Expressions --

/// Evaluate an expression and format the result for a terminal.
///
/// The programmer configuration (width, signedness, byte order) is explicit because
/// the flags that set it are. Standard mode ignores it: it is fixed at 64-bit signed.
/// There used to be a two-argument `evaluate` in front of this that defaulted the
/// configuration, and by the end only the tests called it.
pub fn evaluateWith(
    allocator: std.mem.Allocator,
    expression: []const u8,
    mode: Mode,
    config: engine.programmer.Config,
    buf: []u8,
) Result {
    if (mode == .programmer) {
        const result = engine.evalProgrammerString(allocator, expression, config) catch |err| {
            return .fail(err);
        };
        return programmerResult(buf, result, config);
    }

    var env = engine.Environment.init(allocator);
    defer env.deinit();

    // A standalone "to" keyword means this is a unit conversion, e.g.
    // "32F to C". Anything without it falls through to normal evaluation.
    if (engine.units.parseRequest(expression)) |maybe_request| {
        if (maybe_request) |request| {
            var value = engine.evalString(&env, allocator, request.value_text) catch |err| return .fail(err);
            defer value.deinit();
            return conversionUnits(allocator, buf, value, request.from, request.to);
        }
    } else |err| return .fail(err);

    var info = engine.evalStringInfo(&env, allocator, expression) catch |err| return .fail(err);
    defer info.value.deinit();

    const shown = info.value.render(allocator, display_format) catch |err| return .fail(err);
    defer shown.deinit(allocator);

    // The hex, octal and binary rows, when the expression used a non-decimal literal
    // and the answer is a whole number that fits a pattern (FR-1.9).
    if (info.basePattern()) |int| return standardMultiBase(buf, shown.text, int);

    // Into the caller's buffer, so the result does not depend on the allocator
    // outliving this call.
    return .ok(std.fmt.bufPrint(buf, "{s}\n", .{shown.text}) catch return .too_long);
}

/// A standard-mode result with its multi-base rows. The rows print themselves, and
/// `dec_display` is the caller's allocated text rather than a slice of `buf`, so
/// writing into `buf` cannot clobber it.
fn standardMultiBase(buf: []u8, dec_display: []const u8, int: engine.Integer) Result {
    return .ok(std.fmt.bufPrint(buf, "{s}\n  hex: {f}\n  oct: {f}\n  bin: {f}\n", .{
        dec_display,
        int.fmt(.hex, .{}),
        int.fmt(.octal, .{}),
        int.fmt(.binary, .{}),
    }) catch return .too_long);
}

fn programmerResult(buf: []u8, result: engine.Integer, config: engine.programmer.Config) Result {
    return .ok(std.fmt.bufPrint(buf,
        \\  dec(signed):   {f}
        \\  dec(unsigned): {f}
        \\  hex: {f}
        \\  oct: {f}
        \\  bin: {f}
        \\
    , .{
        result.fmt(.decimal_signed, .{}),
        result.fmt(.decimal_unsigned, .{}),
        result.fmt(.hex, .{ .endian = config.display_endian }),
        result.fmt(.octal, .{}),
        result.fmt(.binary, .{}),
    }) catch return .too_long);
}

// -- Conversions --

/// Format a unit conversion between two resolved units.
///
/// The value is parsed exactly rather than through f64, so a decimal input like 2.5
/// enters the conversion without being rounded first. The units arrive resolved
/// because `units.parseRequest` resolved them while reading the request, so there is
/// no second lookup here and no second `UnknownUnit` path.
pub fn conversion(
    allocator: std.mem.Allocator,
    buf: []u8,
    value_text: []const u8,
    from: engine.UnitDef,
    to: engine.UnitDef,
) Result {
    // Parse the value exactly rather than through f64, so a decimal input like
    // 2.5 enters the conversion without being rounded first.
    var value = engine.Number.parse(allocator, value_text) catch |err| return .fail(err);
    defer value.deinit();

    return conversionUnits(allocator, buf, value, from, to);
}

/// Format a conversion of a value that has already been evaluated, which is what a
/// bare expression such as `2*3 kg to lb` arrives as.
///
/// Uses the exact path so terminating conversions print exactly: `12 in to ft`
/// is `1`, not `0.9999999999999998`.
fn conversionUnits(
    allocator: std.mem.Allocator,
    buf: []u8,
    value: engine.Number,
    from: engine.UnitDef,
    to: engine.UnitDef,
) Result {
    var converted = engine.units.convertExactUnits(allocator, value, from, to) catch |err| return .fail(err);
    defer converted.deinit();

    const shown_in = value.render(allocator, display_format) catch |err| return .fail(err);
    defer shown_in.deinit(allocator);
    const shown_out = converted.render(allocator, display_format) catch |err| return .fail(err);
    defer shown_out.deinit(allocator);

    return .ok(std.fmt.bufPrint(buf, "{s} {s} = {s} {s}\n", .{
        shown_in.text, from.name, shown_out.text, to.name,
    }) catch return .too_long);
}

// -- Amortization --

/// Render an amortization schedule as a table. The result is allocated because a
/// 360-period schedule does not fit the fixed buffers the other outputs use.
pub fn amortization(
    allocator: std.mem.Allocator,
    params: engine.financial.AmortizationParams,
    summary_only: bool,
) Result {
    const payment = engine.financial.amortizationPayment(params) catch |err| return amortizationError(err);
    const totals = engine.financial.amortizationTotals(params) catch |err| return amortizationError(err);
    const rows = engine.financial.amortizationSchedule(allocator, params) catch |err| return amortizationError(err);
    defer allocator.free(rows);

    var out: std.Io.Writer.Allocating = .init(allocator);
    defer out.deinit();
    writeSchedule(&out.writer, params, payment, rows, totals, summary_only) catch |err| return switch (err) {
        error.Unformattable => unformattable,
        error.WriteFailed => .fail(error.OutOfMemory),
    };
    return .ok(out.toOwnedSlice() catch return .fail(error.OutOfMemory));
}

fn writeSchedule(
    w: *std.Io.Writer,
    params: engine.financial.AmortizationParams,
    payment: f64,
    rows: []const engine.financial.AmortizationEntry,
    totals: engine.financial.AmortizationTotals,
    summary_only: bool,
) (std.Io.Writer.Error || error{Unformattable})!void {
    var a: [4]Amount = undefined;
    try w.print("{s} at {d}% per period over {d} periods\n", .{ try a[0].of(params.principal), params.rate, params.periods });
    try w.print("Payment {s} per period\n\n", .{try a[0].of(payment)});

    if (!summary_only) {
        try w.writeAll("Period       Payment      Interest     Principal       Balance\n");
        for (rows) |row| {
            try w.print("{d: >6}  {s: >12}  {s: >12}  {s: >12}  {s: >12}\n", .{
                row.period,
                try a[0].of(row.payment),
                try a[1].of(row.interest),
                try a[2].of(row.principal),
                try a[3].of(row.balance),
            });
        }
        try w.writeAll("\n");
    }

    try w.print("Periods paid   {d}\nTotal paid     {s}\nTotal interest {s}\nPrincipal      {s}\n", .{
        totals.periods,
        try a[0].of(totals.paid),
        try a[1].of(totals.interest),
        try a[2].of(totals.principal),
    });
}

/// Room for one amount's text, for the columns that pad it. Rendered rather than
/// printed with `{f}` so that an amount too large to render is told apart from a
/// writer that has run out of memory.
const Amount = struct {
    buf: [64]u8,

    fn of(self: *Amount, value: f64) error{Unformattable}![]const u8 {
        return money(value).render(&self.buf) catch error.Unformattable;
    }
};

// -- Struct layout --

const struct_layout = engine.struct_layout;
const CStructParser = engine.CStructParser;

/// Members a memory map can tell apart, one letter each: a-z, then A-Z.
const max_keyed_members = 52;

/// Whether a struct layout is drawn in color. Deciding (a terminal, `NO_COLOR`,
/// `--color`) is `main`'s job; this only carries the answer.
///
/// Color is a second channel, never the only one: every member keeps its letter, so
/// the output means the same thing piped, pasted, or read by someone who cannot tell
/// the hues apart. What color adds is that a member's bytes read as one block in the
/// map, its row in the table is the same hue, and padding falls back as faint gaps.
pub const Paint = enum {
    plain,
    ansi,

    /// The terminal's own six hues rather than fixed RGB values, so the user's theme
    /// decides what they look like and keeps them readable on its own background.
    /// Cycled by member index, so neighbouring members never share one. Each starts
    /// with a reset because faint persists until something clears it.
    const hues = [_][]const u8{
        "\x1b[0;36m", // cyan
        "\x1b[0;33m", // yellow
        "\x1b[0;35m", // magenta
        "\x1b[0;32m", // green
        "\x1b[0;34m", // blue
        "\x1b[0;31m", // red
    };
    /// Faint (SGR 2) rather than "bright black", which some themes (Solarized among
    /// them) draw in nearly the background color.
    const faint = "\x1b[0;2m";
    const reset = "\x1b[0m";

    fn member(self: Paint, index: usize) []const u8 {
        return self.use(hues[index % hues.len]);
    }

    fn padding(self: Paint) []const u8 {
        return self.use(faint);
    }

    fn end(self: Paint) []const u8 {
        return self.use(reset);
    }

    /// `code` when painting, nothing when plain.
    fn use(self: Paint, code: []const u8) []const u8 {
        return if (self == .ansi) code else "";
    }
};

/// Lay out a C struct and render it: a table of members and padding, a summary line,
/// and a memory map with one letter per byte. Allocated, because a struct's table has
/// no useful upper bound.
pub fn structLayout(
    allocator: std.mem.Allocator,
    source: []const u8,
    abi: *const struct_layout.Abi,
    paint: Paint,
) Result {
    var diag: CStructParser.Diagnostic = .{};
    var parsed = CStructParser.parse(allocator, source, &diag) catch |err| {
        return located(allocator, err, source, diag.span);
    };
    defer parsed.deinit();
    const definition = parsed.definition;

    var layout_diag: struct_layout.Diagnostic = .{};
    var layout = struct_layout.compute(allocator, definition, abi, &layout_diag) catch |err| {
        const span = if (layout_diag.member) |i| definition.members[i].span else null;
        return located(allocator, err, source, span);
    };
    defer layout.deinit(allocator);

    var scratch: std.heap.ArenaAllocator = .init(allocator);
    defer scratch.deinit();
    const rows = tableRows(scratch.allocator(), definition, &layout) catch |err| return .fail(err);

    var out: std.Io.Writer.Allocating = .init(allocator);
    defer out.deinit();
    writeLayout(&out.writer, rows, definition, &layout, paint) catch return .fail(error.OutOfMemory);
    const text = out.toOwnedSlice() catch |err| return .fail(err);
    return .{ .output = text, .is_error = false };
}

/// An error, and where in the definition it is, when it is anywhere in particular:
///
///     error: unknown type (typedefs and macros from elsewhere are not visible)
///       line 3, column 5: uint33_t
fn located(allocator: std.mem.Allocator, err: engine.Error, source: []const u8, span: ?struct_layout.Span) Result {
    // Running out of memory is about the machine, not a place in the input, and the
    // parser's diagnostic always holds a span, so this comes first.
    if (err == error.OutOfMemory) return .fail(err);
    const s = span orelse return .fail(err);
    const at = CStructParser.locate(source, s.start);
    const text = source[s.start..][0..s.len];
    // One line of it, and not much of that: a directive is reported whole.
    const line_end = std.mem.indexOfScalar(u8, text, '\n') orelse text.len;
    const shown = text[0..@min(line_end, 40)];
    const output = std.fmt.allocPrint(allocator, "error: {s}\n  line {d}, column {d}{s}{s}\n", .{
        engine.phrase(err),
        at.line,
        at.column,
        if (shown.len == 0) ", at the end of the input" else ": ",
        shown,
    }) catch return .fail(error.OutOfMemory);
    return .{ .output = output, .is_error = true };
}

/// The letter a member is drawn with in the map, matching its row in the table.
fn memberKey(index: usize) u8 {
    if (index < 26) return @intCast('a' + index);
    if (index < max_keyed_members) return @intCast('A' + index - 26);
    return ' ';
}

/// A count with thousands separators (NFR-7), printed with `{f}`.
const Grouped = struct {
    n: u64,

    pub fn format(self: Grouped, w: *std.Io.Writer) std.Io.Writer.Error!void {
        var digits: [20]u8 = undefined;
        const len = std.fmt.printInt(&digits, self.n, 10, .lower, .{});
        try engine.grouping.print(w, digits[0..len]);
    }
};

/// A member's type as a person writes it, dimensions included: `char[16]`,
/// `int[2][3]`, `double[]`. Printed with `{f}`.
const TypeName = struct {
    member: struct_layout.Member,

    pub fn format(self: TypeName, w: *std.Io.Writer) std.Io.Writer.Error!void {
        try w.writeAll(self.member.type_name);
        if (self.member.flexible) try w.writeAll("[]");
        for (self.member.dims) |dim| try w.print("[{d}]", .{dim});
    }
};

/// One line of the table, its cells rendered to text once. A column's width is
/// measured from the same text that is printed, so the two cannot disagree.
const Row = struct {
    kind: union(enum) { header, member: usize, padding },
    offset: []const u8,
    size: []const u8,
    alignment: []const u8,
    type: []const u8,
    name: []const u8,
};

/// The table: a header, then one row per segment of the layout, which is the same
/// list the memory map draws. Allocated in `arena`, which the caller releases.
fn tableRows(arena: std.mem.Allocator, def: struct_layout.Definition, layout: *const struct_layout.Layout) ![]const Row {
    var rows: std.ArrayList(Row) = .empty;
    try rows.append(arena, .{
        .kind = .header,
        .offset = "Offset",
        .size = "Size",
        .alignment = "Align",
        .type = "Type",
        .name = "Name",
    });
    var it = layout.segments();
    while (it.next()) |seg| {
        const offset = try std.fmt.allocPrint(arena, "{f}", .{Grouped{ .n = seg.offset }});
        const size = try std.fmt.allocPrint(arena, "{f}", .{Grouped{ .n = seg.len }});
        try rows.append(arena, switch (seg.kind) {
            .member => |i| .{
                .kind = .{ .member = i },
                .offset = offset,
                .size = size,
                .alignment = try std.fmt.allocPrint(arena, "{f}", .{Grouped{ .n = layout.placements[i].alignment }}),
                .type = try std.fmt.allocPrint(arena, "{f}", .{TypeName{ .member = def.members[i] }}),
                .name = def.members[i].name,
            },
            .padding, .tail => .{
                .kind = .padding,
                .offset = offset,
                .size = size,
                .alignment = "",
                .type = "",
                .name = if (seg.kind == .tail) "(tail padding)" else "(padding)",
            },
        });
    }
    return rows.items;
}

/// The widest cell in each column.
const Widths = struct {
    offset: usize = 0,
    size: usize = 0,
    alignment: usize = 0,
    type: usize = 0,

    fn of(rows: []const Row) Widths {
        var widths: Widths = .{};
        for (rows) |row| {
            widths.offset = @max(widths.offset, row.offset.len);
            widths.size = @max(widths.size, row.size.len);
            widths.alignment = @max(widths.alignment, row.alignment.len);
            widths.type = @max(widths.type, row.type.len);
        }
        return widths;
    }
};

/// A member row colors its key and its name, which is enough to find its bytes in the
/// map without turning the table into a wall of color. A padding row is faint from
/// end to end, and the header is plain.
fn writeRow(w: *std.Io.Writer, row: Row, widths: Widths, paint: Paint) std.Io.Writer.Error!void {
    const key: u8, const key_color: []const u8, const key_end: []const u8, const name_color: []const u8 =
        switch (row.kind) {
            .header => .{ ' ', "", "", "" },
            .member => |i| .{ memberKey(i), paint.member(i), paint.end(), paint.member(i) },
            .padding => .{ ' ', paint.padding(), "", "" },
        };
    const line_end = if (row.kind == .header) "" else paint.end();
    try w.print("  {[kc]s}{[key]c}{[ke]s}  {[offset]s: >[ow]}  {[size]s: >[sw]}  {[alignment]s: >[aw]}" ++
        "  {[type]s: <[tw]}  {[nc]s}{[name]s}{[end]s}\n", .{
        .kc = key_color,
        .key = key,
        .ke = key_end,
        .offset = row.offset,
        .ow = widths.offset,
        .size = row.size,
        .sw = widths.size,
        .alignment = row.alignment,
        .aw = widths.alignment,
        .type = row.type,
        .tw = widths.type,
        .nc = name_color,
        .name = row.name,
        .end = line_end,
    });
}

fn writeLayout(
    w: *std.Io.Writer,
    rows: []const Row,
    def: struct_layout.Definition,
    layout: *const struct_layout.Layout,
    paint: Paint,
) std.Io.Writer.Error!void {
    if (def.name) |name| switch (def.name_kind) {
        .tag => try w.print("struct {s}\n", .{name}),
        .typedef => try w.print("{s}\n", .{name}),
    } else try w.writeAll("struct (anonymous)\n");
    try w.print("ABI {s}: {s}\n\n", .{ layout.abi.id, layout.abi.label });

    const widths: Widths = .of(rows);
    for (rows) |row| try writeRow(w, row, widths, paint);

    // The summary: what a reader came for.
    try w.print("\n  {f} {s}, alignment {d}, ", .{ Grouped{ .n = layout.size }, bytes(layout.size), layout.alignment });
    const padding = layout.padding();
    if (padding == 0) {
        try w.writeAll("no padding\n");
    } else {
        try w.print("{f} {s} of padding (", .{ Grouped{ .n = padding }, bytes(padding) });
        try writePercent(w, padding, layout.size);
        try w.print("); {f} {s} packed\n", .{ Grouped{ .n = layout.packed_size }, bytes(layout.packed_size) });
    }

    if (layout.size == 0) return;
    if (def.members.len > max_keyed_members) {
        try w.print("\n  (no memory map: more than {d} members to tell apart)\n", .{max_keyed_members});
        return;
    }
    try w.writeAll("\n");
    try writeMap(w, layout, paint);
}

fn bytes(n: u64) []const u8 {
    return if (n == 1) "byte" else "bytes";
}

/// `part` as a percentage of `whole`, rounded half up to two places, with trailing
/// zeros dropped: 6.25%, 50%, 33.33%. In integer hundredths, so no float rounding
/// decides what is printed.
fn writePercent(w: *std.Io.Writer, part: u64, whole: u64) std.Io.Writer.Error!void {
    const hundredths: u128 = (@as(u128, part) * 20000 + whole) / (@as(u128, whole) * 2);
    const units = hundredths / 100;
    const frac = hundredths % 100;
    if (frac == 0) {
        try w.print("{d}%", .{units});
    } else if (frac % 10 == 0) {
        try w.print("{d}.{d}%", .{ units, frac / 10 });
    } else {
        try w.print("{d}.{d:0>2}%", .{ units, frac });
    }
}

/// The segment holding a byte, for bytes visited in increasing order.
const SegmentCursor = struct {
    it: struct_layout.SegmentIterator,
    current: struct_layout.Segment,
    /// How many segments have been passed: which one `current` is.
    index: usize = 0,

    fn init(layout: *const struct_layout.Layout) SegmentCursor {
        var it = layout.segments();
        const first = it.next().?;
        return .{ .it = it, .current = first };
    }

    /// Zero-length segments are passed over, since no byte is in them.
    fn at(self: *SegmentCursor, offset: u64) struct_layout.Segment {
        while (self.current.offset + self.current.len <= offset) {
            self.current = self.it.next().?;
            self.index += 1;
        }
        return self.current;
    }
};

/// Sixteen bytes a row, each drawn as its member's letter or `.` for padding, in
/// groups of four. A row identical to the one above it is collapsed to `*`, as
/// hexdump does, so `char buf[4096]` costs two lines rather than 256. Rows are found
/// from the segments rather than walked byte by byte, so a struct the size of an
/// address space costs no more than one with the same number of members.
///
/// In color, a code is written only where the color changes, so a member's run of
/// bytes, gaps included, is one span of one hue.
fn writeMap(w: *std.Io.Writer, layout: *const struct_layout.Layout, paint: Paint) std.Io.Writer.Error!void {
    const per_row = 16;
    const size = layout.size;
    const rows = (size + per_row - 1) / per_row;
    const last_offset = (rows - 1) * per_row;
    var label_digits: usize = 2;
    while (label_digits < 16 and last_offset >> @intCast(label_digits * 4) != 0) label_digits += 1;

    var cursor: SegmentCursor = .init(layout);
    // The segment the last printed row lay wholly inside, if it did.
    var previous_whole: ?usize = null;
    var starred = false;

    var row: u64 = 0;
    while (row < rows) {
        const start = row * per_row;
        const end = @min(start + per_row, size);
        const seg = cursor.at(start);
        const whole = end - start == per_row and seg.offset + seg.len >= end;
        if (whole and previous_whole == cursor.index) {
            if (!starred) try w.writeAll("  *\n");
            starred = true;
            // Straight to the first row this segment does not fill.
            row = (seg.offset + seg.len) / per_row;
            continue;
        }
        starred = false;
        previous_whole = if (whole) cursor.index else null;

        try w.writeAll("  0x");
        try w.printInt(start, 16, .lower, .{ .fill = '0', .width = label_digits });
        var bytes_cursor = cursor;
        var current: []const u8 = "";
        for (start..end) |offset| {
            const glyph: u8, const color = switch (bytes_cursor.at(offset).kind) {
                .member => |i| .{ memberKey(i), paint.member(i) },
                .padding, .tail => .{ '.', paint.padding() },
            };
            try w.writeAll(if ((offset - start) % 4 == 0) "  " else " ");
            if (!std.mem.eql(u8, color, current)) {
                try w.writeAll(color);
                current = color;
            }
            try w.writeByte(glyph);
        }
        try w.print("{s}\n", .{paint.end()});
        row += 1;
    }
}

// -- Errors --

/// Turn an engine error into a CLI line: "error: <phrase>\n".
///
/// The phrases live once, in `engine.phrase`. This adds the prefix and the newline at
/// comptime, so the strings still have static lifetime and there is no second copy of
/// the wording to drift. The CLI and the TUI previously each kept their own switch
/// over the whole error set; the TUI's was already missing three cases and rendered
/// them as "evaluation error".
///
/// `inline else` makes this exhaustive with no fallback branch: an error added
/// anywhere in the engine fails to compile in `engine.phrase` rather than silently
/// reading "evaluation error" here. Reached through `Result.fail`.
fn decoratedError(err: engine.Error) []const u8 {
    return switch (err) {
        inline else => |e| comptime "error: " ++ engine.phrase(e) ++ "\n",
    };
}

/// The loan terms a schedule cannot be built from, in the words of the thing the
/// user actually typed.
fn amortizationError(err: engine.Error) Result {
    return switch (err) {
        // The realistic causes are all one of these, and a bare "domain error"
        // would leave the user guessing which.
        engine.Error.DomainError => .{
            .output = "error: check the loan terms: principal and periods must be positive, the rate cannot be negative, and the payment must at least cover the first period's interest\n",
            .is_error = true,
        },
        else => .fail(err),
    };
}

/// An amount too large to render. Reported rather than printed as a placeholder:
/// the previous local formatter returned "?" for these, so a table of question
/// marks came out with exit status 0.
const unformattable: Result = .{
    .output = "error: an amount in this schedule is too large to format\n",
    .is_error = true,
};

// -- Tests --

const testing = std.testing;

/// A unit by name, for the tests that call a formatter directly. In the real paths
/// `units.parseRequest` has already resolved both units by the time a formatter sees
/// them, which is why the formatters take `UnitDef` rather than names.
fn unit(name: []const u8) engine.UnitDef {
    return engine.units.findUnit(name).?;
}

test "evaluate: standard arithmetic" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "2 + 2", .standard, .{}, &buf);
    try testing.expect(!result.is_error);
    try testing.expectEqualStrings("4\n", result.output);
}

test "evaluate: large number has commas" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "2^32 - 1", .standard, .{}, &buf);
    try testing.expect(!result.is_error);
    try testing.expectEqualStrings("4,294,967,295\n", result.output);
}

test "evaluate: function" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "sin(pi/2) + 1", .standard, .{}, &buf);
    try testing.expect(!result.is_error);
    try testing.expectEqualStrings("2\n", result.output);
}

test "evaluate: explicit mul" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "3*(4+5)", .standard, .{}, &buf);
    try testing.expect(!result.is_error);
    try testing.expectEqualStrings("27\n", result.output);
}

test "evaluate: programmer mode" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "0xFF & 0x0F", .programmer, .{}, &buf);
    try testing.expect(!result.is_error);
    try testing.expect(std.mem.indexOf(u8, result.output, "15") != null);
    try testing.expect(std.mem.indexOf(u8, result.output, "00 00 00 00 00 00 00 0F") != null);
}

test "evaluate: division by zero error" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "1/0", .standard, .{}, &buf);
    try testing.expect(result.is_error);
    try testing.expectEqualStrings("error: division by zero\n", result.output);
}

test "evaluate: unknown variable error" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "xyz + 1", .standard, .{}, &buf);
    try testing.expect(result.is_error);
    try testing.expectEqualStrings("error: unknown variable\n", result.output);
}

test "evaluate: an expression written in another base answers in every base" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;

    // Standard mode, but a hex literal says the user is thinking in bases, so the
    // answer carries the other three rather than only decimal.
    const hex = evaluateWith(arena.allocator(), "0xFF + 1", .standard, .{}, &buf);
    try testing.expect(!hex.is_error);
    try testing.expectEqualStrings(
        \\256
        \\  hex: 01 00
        \\  oct: 000 400
        \\  bin: 0000 0001 0000 0000
        \\
    , hex.output);

    // The rows are as wide as the value needs and no wider: 10 fits one byte, where
    // 256 above needed two. Standard mode has no width setting to consult, so the
    // value chooses.
    const binary = evaluateWith(arena.allocator(), "0b1010", .standard, .{}, &buf);
    try testing.expect(!binary.is_error);
    try testing.expectEqualStrings(
        \\10
        \\  hex: 0A
        \\  oct: 012
        \\  bin: 0000 1010
        \\
    , binary.output);

    // The decimal line is the ordinary rendering, so it still groups its digits.
    const octal = evaluateWith(arena.allocator(), "0o777 * 2", .standard, .{}, &buf);
    try testing.expect(!octal.is_error);
    try testing.expect(std.mem.startsWith(u8, octal.output, "1,022\n"));
    try testing.expect(std.mem.indexOf(u8, octal.output, "hex: 03 FE") != null);

    // Past 2^53 the rows agree with the decimal line above them. They came from an
    // f64 and read `DE AD BE EF DE AD C0 00` under the right decimal (open item 3).
    const wide = evaluateWith(arena.allocator(), "0xDEADBEEFDEADBEEF", .standard, .{}, &buf);
    try testing.expectEqualStrings(
        \\16,045,690,984,833,335,023
        \\  hex: DE AD BE EF DE AD BE EF
        \\  oct: 1 572 555 756 773 653 337 357
        \\  bin: 1101 1110 1010 1101 1011 1110 1110 1111 1101 1110 1010 1101 1011 1110 1110 1111
        \\
    , wide.output);
}

test "evaluate: a non-decimal literal with no whole answer stays decimal" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;

    // The rows show a u128 bit pattern, and neither of these has one, so the answer
    // is rendered plainly instead of in four bases. Standard mode is not programmer
    // mode: it does not wrap a negative into two's complement to have something to
    // print.
    const negative = evaluateWith(arena.allocator(), "0xFF - 0x100", .standard, .{}, &buf);
    try testing.expect(!negative.is_error);
    try testing.expectEqualStrings("-1\n", negative.output);

    const fractional = evaluateWith(arena.allocator(), "0xFF / 2", .standard, .{}, &buf);
    try testing.expect(!fractional.is_error);
    try testing.expectEqualStrings("127.5\n", fractional.output);
}

test "evaluate: multi-base rows that outgrow the buffer are refused, not truncated" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();

    // Enough room for the decimal answer alone, nowhere near enough for the rows.
    // Half a table would read as a wrong answer, so nothing is printed.
    var small: [8]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "0xFF + 1", .standard, .{}, &small);
    try testing.expect(result.is_error);
    try testing.expectEqualStrings("error: the result is too long to display\n", result.output);
}

test "the programmer config reaches the result" {
    var buf: [4096]u8 = undefined;
    var arena = std.heap.ArenaAllocator.init(testing.allocator);
    defer arena.deinit();
    const alloc = arena.allocator();

    // 8-bit: 0xFF + 1 wraps to 0.
    const narrow = evaluateWith(alloc, "0xFF + 1", .programmer, .{ .width = .bits8 }, &buf);
    try testing.expect(!narrow.is_error);
    try testing.expect(std.mem.indexOf(u8, narrow.output, "dec(unsigned): 0\n") != null);

    // Signedness decides whether >> extends the sign.
    const signed = evaluateWith(alloc, "0xFF >> 1", .programmer, .{
        .width = .bits8,
        .signedness = .signed,
    }, &buf);
    try testing.expect(std.mem.indexOf(u8, signed.output, "dec(signed):   -1") != null);

    const unsigned = evaluateWith(alloc, "0xFF >> 1", .programmer, .{
        .width = .bits8,
        .signedness = .unsigned,
    }, &buf);
    try testing.expect(std.mem.indexOf(u8, unsigned.output, "dec(unsigned): 127") != null);

    // Byte order reverses the hex row and nothing else.
    const little = evaluateWith(alloc, "0xDEAD", .programmer, .{
        .width = .bits16,
        .display_endian = .little,
    }, &buf);
    try testing.expect(std.mem.indexOf(u8, little.output, "hex: AD DE") != null);
    const big = evaluateWith(alloc, "0xDEAD", .programmer, .{
        .width = .bits16,
        .display_endian = .big,
    }, &buf);
    try testing.expect(std.mem.indexOf(u8, big.output, "hex: DE AD") != null);
}

test "conversion: km to mi" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [256]u8 = undefined;
    const result = conversion(arena.allocator(), &buf, "100", unit("km"), unit("mi"));
    try testing.expect(!result.is_error);
    try testing.expect(std.mem.indexOf(u8, result.output, "62.137") != null);
    try testing.expect(std.mem.indexOf(u8, result.output, "km") != null);
    try testing.expect(std.mem.indexOf(u8, result.output, "mi") != null);
}

test "conversion: temperature freezing point" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [256]u8 = undefined;
    const result = conversion(arena.allocator(), &buf, "0", unit("C"), unit("F"));
    try testing.expect(!result.is_error);
    try testing.expectEqualStrings("0 C = 32 F\n", result.output);
}

test "conversion: incompatible units is an error" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [256]u8 = undefined;
    const result = conversion(arena.allocator(), &buf, "1", unit("kg"), unit("m"));
    try testing.expect(result.is_error);
    try testing.expect(std.mem.indexOf(u8, result.output, "incompatible") != null);
}

test "conversion: alias resolves to canonical name in output" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [256]u8 = undefined;
    const result = conversion(arena.allocator(), &buf, "1", unit("kilometer"), unit("meters"));
    try testing.expect(!result.is_error);
    // Conversion output now uses the standard comma grouping (NFR-7).
    try testing.expectEqualStrings("1 km = 1,000 m\n", result.output);
}

test "conversion: exact conversion prints exactly" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [256]u8 = undefined;

    // The bug this task exists to fix.
    const feet = conversion(arena.allocator(), &buf, "12", unit("in"), unit("ft"));
    try testing.expect(!feet.is_error);
    try testing.expectEqualStrings("12 in = 1 ft\n", feet.output);

    // Exact affine conversion.
    const celsius = conversion(arena.allocator(), &buf, "98.6", unit("F"), unit("C"));
    try testing.expect(!celsius.is_error);
    try testing.expectEqualStrings("98.6 F = 37 C\n", celsius.output);

    // Exact fractional factor.
    const mps = conversion(arena.allocator(), &buf, "3.6", unit("km/h"), unit("m/s"));
    try testing.expect(!mps.is_error);
    try testing.expectEqualStrings("3.6 km/h = 1 m/s\n", mps.output);
}

test "evaluate: bare conversion expression without subcommand" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "100 km to mi", .standard, .{}, &buf);
    try testing.expect(!result.is_error);
    try testing.expect(std.mem.indexOf(u8, result.output, "62.137") != null);
}

test "evaluate: glued bare conversion" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "32F to C", .standard, .{}, &buf);
    try testing.expect(!result.is_error);
    try testing.expectEqualStrings("32 F = 0 C\n", result.output);
}

test "evaluate: conversion value may be an expression" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "2*3 kg to g", .standard, .{}, &buf);
    try testing.expect(!result.is_error);
    try testing.expectEqualStrings("6 kg = 6,000 g\n", result.output);
}

test "evaluate: bare conversion with unknown unit errors" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "100 km to smoots", .standard, .{}, &buf);
    try testing.expect(result.is_error);
    try testing.expect(std.mem.indexOf(u8, result.output, "unknown unit") != null);
}

test "evaluate: bare conversion with incompatible units errors" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "1 kg to m", .standard, .{}, &buf);
    try testing.expect(result.is_error);
    try testing.expect(std.mem.indexOf(u8, result.output, "incompatible") != null);
}

test "evaluate: ordinary expressions are unaffected by conversion detection" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    const result = evaluateWith(arena.allocator(), "2 + 3 * 4", .standard, .{}, &buf);
    try testing.expect(!result.is_error);
    try testing.expectEqualStrings("14\n", result.output);
}

test "evaluate: expression containing a unit-like name still evaluates" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();
    var buf: [4096]u8 = undefined;
    // "e" is Euler's number here, not a unit, because there is no "to" keyword.
    const result = evaluateWith(arena.allocator(), "e", .standard, .{}, &buf);
    try testing.expect(!result.is_error);
    try testing.expect(std.mem.startsWith(u8, result.output, "2.718"));
}

test "amortization: an unrenderable amount is an error, not a table of marks" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();

    // 1e40 used to produce a full report of "?" with exit status 0. It now fits,
    // because the engine formatter groups the whole number.
    const large = amortization(arena.allocator(), .{
        .principal = 1e40,
        .rate = 0.5,
        .periods = 3,
    }, false);
    try testing.expect(!large.is_error);
    try testing.expect(std.mem.indexOfScalar(u8, large.output, '?') == null);
    try testing.expect(std.mem.indexOf(u8, large.output, "10,000,000,000,000,000,000,000,000,000,000,000,000,000.00") != null);

    // Past the width of the formatting buffer the report is refused outright, with
    // a non-zero exit status, rather than printed with placeholders.
    const huge = amortization(arena.allocator(), .{
        .principal = 1e60,
        .rate = 0.5,
        .periods = 3,
    }, false);
    try testing.expect(huge.is_error);
    try testing.expect(std.mem.indexOf(u8, huge.output, "too large to format") != null);
    try testing.expect(std.mem.indexOfScalar(u8, huge.output, '?') == null);
}

test "amortization: table has a row per period and correct first row" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();

    const result = amortization(arena.allocator(), .{
        .principal = 200000,
        .rate = 0.5,
        .periods = 360,
    }, false);
    try testing.expect(!result.is_error);

    // Header, payment, blank, column head, 360 rows, blank, 4 summary lines, each
    // ending in a newline like every other result.
    try testing.expectEqual(@as(usize, 369), std.mem.count(u8, result.output, "\n"));
    try testing.expect(std.mem.endsWith(u8, result.output, "\n"));

    try testing.expect(std.mem.indexOf(u8, result.output, "Payment 1,199.10 per period") != null);
    try testing.expect(std.mem.indexOf(u8, result.output, "1,000.00") != null);
    try testing.expect(std.mem.indexOf(u8, result.output, "199,800.90") != null);
    try testing.expect(std.mem.indexOf(u8, result.output, "Total interest 231,677.04") != null);
}

test "amortization: summary only omits the rows" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();

    const result = amortization(arena.allocator(), .{
        .principal = 200000,
        .rate = 0.5,
        .periods = 360,
    }, true);
    try testing.expect(!result.is_error);
    try testing.expect(std.mem.indexOf(u8, result.output, "Period       Payment") == null);
    try testing.expect(std.mem.indexOf(u8, result.output, "Periods paid   360") != null);
}

test "amortization: bad terms explain themselves" {
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer _ = arena.deinit();

    // A payment that never covers the interest.
    const result = amortization(arena.allocator(), .{
        .principal = 200000,
        .rate = 0.5,
        .periods = 360,
        .payment = 500,
    }, false);
    try testing.expect(result.is_error);
    try testing.expect(std.mem.indexOf(u8, result.output, "loan terms") != null);
}

test "every result is complete text, ending in exactly one newline" {
    // `main` prints a result as it stands. This held for some outputs and not others:
    // single-line answers relied on `main` adding a newline, and programmer mode,
    // which carried its own, got a second one and ended in a blank line.
    var arena: std.heap.ArenaAllocator = .init(testing.allocator);
    defer arena.deinit();
    const a = arena.allocator();
    // A buffer each: the results that write into one point into it, so sharing one
    // would leave the early results reading the last one's text.
    var bufs: [8][4096]u8 = undefined;
    for ([_]Result{
        evaluateWith(a, "2 + 2", .standard, .{}, &bufs[0]),
        evaluateWith(a, "0xFF + 1", .standard, .{}, &bufs[1]),
        evaluateWith(a, "0xFF", .programmer, .{}, &bufs[2]),
        evaluateWith(a, "100 km to mi", .standard, .{}, &bufs[3]),
        evaluateWith(a, "1 / 0", .standard, .{}, &bufs[4]),
        evaluateWith(a, "1 +", .programmer, .{}, &bufs[5]),
        conversion(a, &bufs[6], "100", engine.units.findUnit("km").?, engine.units.findUnit("mi").?),
        conversion(a, &bufs[7], "abc", engine.units.findUnit("km").?, engine.units.findUnit("mi").?),
        amortization(a, .{ .principal = 1000, .rate = 1, .periods = 3 }, false),
        amortization(a, .{ .principal = 1000, .rate = 1, .periods = 3 }, true),
        amortization(a, .{ .principal = -1, .rate = 1, .periods = 3 }, false),
        structLayout(a, "struct { int a; char b; }", struct_layout.default_abi, .plain),
        structLayout(a, "struct { int a; char b; }", struct_layout.default_abi, .ansi),
        structLayout(a, "struct { bad b; }", struct_layout.default_abi, .plain),
    }) |result| {
        try testing.expect(std.mem.endsWith(u8, result.output, "\n"));
        try testing.expect(!std.mem.endsWith(u8, result.output, "\n\n"));
    }
}

// -- Struct layout --

/// What `structLayout` prints for `source` under the profile named `abi`, which must
/// lay out. Allocated in `arena`.
fn rendered(arena: std.mem.Allocator, source: []const u8, abi: []const u8, paint: Paint) ![]const u8 {
    const result = structLayout(arena, source, struct_layout.findAbi(abi).?, paint);
    try testing.expect(!result.is_error);
    return result.output;
}

/// A struct with one more member than the map has letters for.
fn manyMembers(arena: std.mem.Allocator) ![]const u8 {
    var source: std.ArrayList(u8) = .empty;
    try source.appendSlice(arena, "struct { char ");
    for (0..max_keyed_members + 1) |i| try source.print(arena, "{s}m{d}", .{ if (i == 0) "" else ", ", i });
    try source.appendSlice(arena, "; }");
    return source.items;
}

test "structLayout: the design document's example, in full" {
    var arena: std.heap.ArenaAllocator = .init(testing.allocator);
    defer arena.deinit();
    try testing.expectEqualStrings(
        \\struct hdr
        \\ABI sysv64: 64-bit Linux and macOS (x86-64 SysV, AArch64)
        \\
        \\     Offset  Size  Align  Type      Name
        \\  a       0     4      4  uint32_t  magic
        \\  b       4     1      1  uint8_t   ver
        \\          5     1                   (padding)
        \\  c       6     2      2  uint16_t  len
        \\  d       8     8      8  uint64_t  ts
        \\
        \\  16 bytes, alignment 8, 1 byte of padding (6.25%); 15 bytes packed
        \\
        \\  0x00  a a a a  b . c c  d d d d  d d d d
        \\
    , try rendered(arena.allocator(), "struct hdr { uint32_t magic; uint8_t ver; uint16_t len; uint64_t ts; }", "sysv64", .plain));
}

test "structLayout: arrays, a flexible member, and a map that collapses" {
    var arena: std.heap.ArenaAllocator = .init(testing.allocator);
    defer arena.deinit();
    try testing.expectEqualStrings(
        \\buf_t
        \\ABI sysv64: 64-bit Linux and macOS (x86-64 SysV, AArch64)
        \\
        \\     Offset   Size  Align  Type         Name
        \\  a       0      4      4  int          len
        \\  b       4  4,096      1  char[4096]   data
        \\  c   4,100     12      2  short[2][3]  grid
        \\  d   4,112      0      8  double[]     flex
        \\
        \\  4,112 bytes, alignment 8, no padding
        \\
        \\  0x0000  a a a a  b b b b  b b b b  b b b b
        \\  0x0010  b b b b  b b b b  b b b b  b b b b
        \\  *
        \\  0x1000  b b b b  c c c c  c c c c  c c c c
        \\
    , try rendered(arena.allocator(), "typedef struct { int len; char data[4096]; short grid[2][3]; double flex[]; } buf_t;", "sysv64", .plain));
}

test "structLayout: a struct under another ABI says so and lays out by its rules" {
    var arena: std.heap.ArenaAllocator = .init(testing.allocator);
    defer arena.deinit();
    const out = try rendered(arena.allocator(), "struct { char c; long l; }", "win64", .plain);
    try testing.expect(std.mem.startsWith(u8, out, "struct (anonymous)\nABI win64: 64-bit Windows (x64, ARM64)\n"));
    try testing.expect(std.mem.indexOf(u8, out, "  b       4     4      4  long  l\n") != null);
    try testing.expect(std.mem.indexOf(u8, out, "8 bytes, alignment 4, 3 bytes of padding (37.5%); 5 bytes packed") != null);
}

test "structLayout: tail padding gets a row and dots of its own" {
    var arena: std.heap.ArenaAllocator = .init(testing.allocator);
    defer arena.deinit();
    try testing.expect(std.mem.endsWith(u8, try rendered(arena.allocator(), "struct tail { uint64_t a; uint8_t b; };", "sysv64", .plain),
        \\  a       0     8      8  uint64_t  a
        \\  b       8     1      1  uint8_t   b
        \\          9     7                   (tail padding)
        \\
        \\  16 bytes, alignment 8, 7 bytes of padding (43.75%); 9 bytes packed
        \\
        \\  0x00  a a a a  a a a a  b . . .  . . . .
        \\
    ));
}

test "structLayout: errors name the problem and where it is" {
    var arena: std.heap.ArenaAllocator = .init(testing.allocator);
    defer arena.deinit();
    const Case = struct { source: []const u8, abi: []const u8 = "sysv64", output: []const u8 };
    for ([_]Case{
        .{
            .source = "struct {\n  int a;\n  uint33_t b;\n}",
            .output = "error: unknown type (typedefs and macros from elsewhere are not visible)\n  line 3, column 3: uint33_t\n",
        },
        .{
            // Errors from laying out point at the member they are about.
            .source = "struct { char c; __int128 big; }",
            .abi = "arm32",
            .output = "error: this type does not exist on the selected ABI\n  line 1, column 27: big\n",
        },
        .{
            .source = "struct { int a;",
            .output = "error: unexpected end of input\n  line 1, column 16, at the end of the input\n",
        },
        .{
            // A directive is reported by its first line, and not much of that.
            .source = "#include \"a/very/long/path/to/a/header/that/goes/on.h\"\nstruct { int a; }",
            .output = "error: only #pragma pack is understood, not other directives\n  line 1, column 1: #include \"a/very/long/path/to/a/header/t\n",
        },
        .{
            // An error about the whole struct has nowhere in particular to point.
            .source = "struct empty { };",
            .output = "error: the struct has no members\n",
        },
    }) |case| {
        const result = structLayout(arena.allocator(), case.source, struct_layout.findAbi(case.abi).?, .plain);
        try testing.expect(result.is_error);
        try testing.expectEqualStrings(case.output, result.output);
    }
}

test "structLayout: more members than letters gets no map, and says why" {
    var arena: std.heap.ArenaAllocator = .init(testing.allocator);
    defer arena.deinit();
    const out = try rendered(arena.allocator(), try manyMembers(arena.allocator()), "sysv64", .plain);
    try testing.expect(std.mem.indexOf(u8, out, "  Z      51     1      1  char  m51\n") != null);
    try testing.expect(std.mem.indexOf(u8, out, "         52     1      1  char  m52\n") != null);
    try testing.expect(std.mem.endsWith(u8, out, "(no memory map: more than 52 members to tell apart)\n"));
}

test "structLayout: a map of a huge struct is as short as a small one" {
    // Two gigabytes of array: walking it byte by byte would not finish.
    var arena: std.heap.ArenaAllocator = .init(testing.allocator);
    defer arena.deinit();
    try testing.expect(std.mem.endsWith(u8, try rendered(arena.allocator(), "struct { char c; double d[268435456]; }", "sysv64", .plain),
        \\  0x00000000  a . . .  . . . .  b b b b  b b b b
        \\  0x00000010  b b b b  b b b b  b b b b  b b b b
        \\  *
        \\  0x80000000  b b b b  b b b b
        \\
    ));
}

test "writePercent drops the zeros it does not need" {
    var buf: [32]u8 = undefined;
    for ([_]struct { part: u64, whole: u64, text: []const u8 }{
        .{ .part = 1, .whole = 16, .text = "6.25%" },
        .{ .part = 1, .whole = 2, .text = "50%" },
        .{ .part = 1, .whole = 3, .text = "33.33%" },
        .{ .part = 3, .whole = 8, .text = "37.5%" },
    }) |case| {
        var w = std.Io.Writer.fixed(&buf);
        try writePercent(&w, case.part, case.whole);
        try testing.expectEqualStrings(case.text, w.buffered());
    }
}

/// `text` with every ANSI escape sequence (ESC, `[`, parameters, a final letter)
/// removed.
fn stripAnsi(allocator: std.mem.Allocator, text: []const u8) ![]u8 {
    var out: std.ArrayList(u8) = .empty;
    var i: usize = 0;
    while (i < text.len) {
        if (text[i] == 0x1b and i + 1 < text.len and text[i + 1] == '[') {
            i += 2;
            while (i < text.len and !std.ascii.isAlphabetic(text[i])) i += 1;
            i += 1;
            continue;
        }
        try out.append(allocator, text[i]);
        i += 1;
    }
    return out.items;
}

test "structLayout: color adds escapes and nothing else" {
    // The letters are the key and color is a second channel, so taking the color
    // away must leave exactly the plain output: same rows, same columns, same map.
    var arena: std.heap.ArenaAllocator = .init(testing.allocator);
    defer arena.deinit();
    const a = arena.allocator();
    for ([_][]const u8{
        "struct hdr { uint32_t magic; uint8_t ver; uint16_t len; uint64_t ts; }",
        "struct tail { uint64_t a; uint8_t b; };",
        "typedef struct { int len; char data[4096]; short grid[2][3]; double flex[]; } buf_t;",
        "struct { char c; double d[268435456]; }",
        "struct { char a; char b; char c; char d; char e; char f; char g; char h; }",
        try manyMembers(a),
    }) |source| {
        const plain = try rendered(a, source, "sysv64", .plain);
        const colored = try rendered(a, source, "sysv64", .ansi);
        try testing.expect(std.mem.indexOfScalar(u8, plain, 0x1b) == null);
        try testing.expect(std.mem.indexOfScalar(u8, colored, 0x1b) != null);
        try testing.expectEqualStrings(plain, try stripAnsi(a, colored));
    }
}

test "structLayout: a member's row and bytes share its hue, and padding is faint" {
    var arena: std.heap.ArenaAllocator = .init(testing.allocator);
    defer arena.deinit();
    const out = try rendered(arena.allocator(), "struct { char c; int i; }", "sysv64", .ansi);
    const first = Paint.hues[0];
    const second = Paint.hues[1];
    const faint = Paint.faint;
    const reset = Paint.reset;

    // In the table: the key and the name, nothing between them.
    try testing.expect(std.mem.indexOf(u8, out, "  " ++ first ++ "a" ++ reset ++ "       0     1      1  char  " ++ first ++ "c" ++ reset ++ "\n") != null);
    try testing.expect(std.mem.indexOf(u8, out, "  " ++ second ++ "b" ++ reset ++ "       4     4      4  int   " ++ second ++ "i" ++ reset ++ "\n") != null);
    // A padding row is faint from its first column to its end.
    try testing.expect(std.mem.indexOf(u8, out, "  " ++ faint ++ "        1     3               (padding)" ++ reset ++ "\n") != null);
    // In the map, a code only where the color changes, and a reset at the end of
    // the row so nothing bleeds into what the terminal prints next.
    try testing.expect(std.mem.endsWith(u8, out, "  0x00  " ++ first ++ "a " ++ faint ++ ". . .  " ++ second ++ "b b b b" ++ reset ++ "\n"));
    // The header, column titles and summary stay plain.
    try testing.expect(std.mem.startsWith(u8, out, "struct (anonymous)\nABI sysv64: 64-bit Linux and macOS (x86-64 SysV, AArch64)\n\n     Offset"));
    try testing.expect(std.mem.indexOf(u8, out, "\n  8 bytes, alignment 4, 3 bytes of padding (37.5%); 5 bytes packed\n") != null);
}

test "Paint: neighbouring members never share a hue, and plain is empty" {
    for (0..max_keyed_members) |i| {
        try testing.expect(!std.mem.eql(u8, Paint.ansi.member(i), Paint.ansi.member(i + 1)));
        try testing.expectEqualStrings("", Paint.plain.member(i));
    }
    try testing.expectEqualStrings("", Paint.plain.padding());
    try testing.expectEqualStrings("", Paint.plain.end());
}