/// CLI `projections` command: retirement projections and benchmark comparison.
///
/// Produces:
///   - Benchmark comparison table (SPY/AGG vs portfolio weighted returns)
///   - Conservative weighted return estimate
///   - Safe withdrawal amounts at multiple horizons and confidence levels
///
/// When `as_of` is non-null, the same output is produced against a
/// historical snapshot instead of the live portfolio. See
/// `src/views/projections.zig:loadProjectionContextAsOf`.
const std = @import("std");
const zfin = @import("../root.zig");
const cli = @import("common.zig");
const fmt = cli.fmt;
const Date = zfin.Date;
const Money = @import("../Money.zig");
const performance = @import("../analytics/performance.zig");
const projections = @import("../analytics/projections.zig");
const benchmark = @import("../analytics/benchmark.zig");
const valuation = @import("../analytics/valuation.zig");
const view = @import("../views/projections.zig");
const history = @import("../history.zig");
const timeline = @import("../analytics/timeline.zig");

/// Hardcoded benchmark symbols (configurable in a future version).
const stock_benchmark = "SPY";
const bond_benchmark = "AGG";

/// How an as-of date resolved against the history directory. The CLI
/// uses this to render a single header that tells the user what
/// actually got loaded (exact hit, nearest-earlier, or straight-up
/// "no snapshot available").
const AsOfResolution = struct {
    /// The requested date, as parsed by the caller.
    requested: Date,
    /// The date that was actually loaded. Differs from `requested`
    /// when we auto-snapped to the nearest-earlier data point.
    actual: Date,
    /// Whether the resolution landed on a native snapshot or an
    /// `imported_values.srf` row. Snapshot wins when both are
    /// available within the at-or-before window.
    source: history.AsOfSourceKind = .snapshot,
    /// Liquid total at `actual`. Filled when `source == .imported`
    /// (read directly from the imported_values row); zero otherwise
    /// — the snapshot path reads its totals from the loaded snapshot.
    liquid: f64 = 0,
};

/// Run projections.
///
/// `as_of` is the reference date for ages, horizons, and snapshot
/// windows. `from_snapshot` selects the data source:
///   - `false`: live mode. Load `file_path` directly. Caller passes
///     today as `as_of`.
///   - `true`: historical mode. Load the snapshot at-or-before
///     `as_of` from the history dir.
pub fn run(
    io: std.Io,
    allocator: std.mem.Allocator,
    svc: *zfin.DataService,
    file_path: []const u8,
    events_enabled: bool,
    as_of: Date,
    from_snapshot: bool,
    today: Date,
    overlay_actuals: bool,
    color: bool,
    out: *std.Io.Writer,
) !void {
    // Single arena for all view/render allocations. Same lifetime
    // regardless of live vs. as-of path.
    var arena_state = std.heap.ArenaAllocator.init(allocator);
    defer arena_state.deinit();
    const va = arena_state.allocator();

    // portfolio_dir is the directory component of file_path, ending
    // in a separator (for the downstream `{s}projections.srf` join).
    const dir_end = if (std.mem.lastIndexOfScalar(u8, file_path, std.fs.path.sep)) |idx| idx + 1 else 0;
    const portfolio_dir = file_path[0..dir_end];

    // Build the context via either the live or as-of pipeline. Both
    // produce a `ProjectionContext`; from that point on rendering is
    // identical.
    var ctx: view.ProjectionContext = undefined;
    var resolution: ?AsOfResolution = null;
    // Snapshot must outlive the context when on the as-of path because
    // `ctx.allocations` borrow their symbol strings from the snapshot's
    // backing buffer. Keep this declared at the outer scope so the
    // defer runs at the end of `run`.
    var snap_bundle: ?history.LoadedSnapshot = null;
    defer if (snap_bundle) |*s| s.deinit(allocator);
    // Live-portfolio bundle. Loaded for the live (no-as-of) path
    // AND for the imported-only as-of path (which uses today's
    // composition scaled to the imported liquid total).
    var live_loaded: ?cli.LoadedPortfolio = null;
    defer if (live_loaded) |*l| l.deinit(allocator);
    var live_pf_data: ?cli.PortfolioData = null;
    defer if (live_pf_data) |*p| p.deinit(allocator);

    if (from_snapshot) {
        resolution = resolveAsOfSnapshot(io, va, file_path, as_of) catch |err| switch (err) {
            error.NoSnapshot => return,
            else => return err,
        };

        if (resolution.?.source == .snapshot) {
            const hist_dir = try history.deriveHistoryDir(va, file_path);
            snap_bundle = try history.loadSnapshotAt(io, allocator, hist_dir, resolution.?.actual);

            ctx = try view.loadProjectionContextAsOf(
                io,
                va,
                portfolio_dir,
                &snap_bundle.?.snap,
                resolution.?.actual,
                svc,
                events_enabled,
            );
        } else {
            // Imported-only as-of: need today's portfolio composition
            // (allocations + cash/CD totals) to scale to the
            // imported liquid value.
            //
            // Today's `as_of` parameter is being repurposed here as
            // the historical reference date for the simulation; for
            // the composition we ALWAYS want today's mix (the only
            // composition we know). Pass `today` for the cash/CD
            // computation.
            live_loaded = cli.loadPortfolio(io, allocator, file_path, today) orelse return;
            const lp = &live_loaded.?;

            var prices = std.StringHashMap(f64).init(allocator);
            defer prices.deinit();
            for (lp.positions) |pos| {
                if (pos.shares <= 0) continue;
                if (svc.getCachedCandles(pos.symbol)) |cs| {
                    defer cs.deinit();
                    if (cs.data.len > 0) {
                        try prices.put(pos.symbol, cs.data[cs.data.len - 1].close);
                    }
                }
            }

            live_pf_data = cli.buildPortfolioData(allocator, lp.portfolio, lp.positions, lp.syms, &prices, svc, today) catch |err| switch (err) {
                error.NoAllocations, error.SummaryFailed => {
                    try cli.stderrPrint(io, "Error computing portfolio summary for imported-only as-of.\n");
                    return;
                },
                else => return err,
            };

            ctx = try view.loadProjectionContextFromImported(
                io,
                va,
                portfolio_dir,
                live_pf_data.?.summary.allocations,
                live_pf_data.?.summary.total_value,
                lp.portfolio.totalCash(today),
                lp.portfolio.totalCdFaceValue(today),
                resolution.?.liquid,
                resolution.?.actual,
                svc,
                events_enabled,
            );
        }
    } else {
        live_loaded = cli.loadPortfolio(io, allocator, file_path, as_of) orelse return;
        const lp = &live_loaded.?;

        // Prices from cache — matches pre-as-of behavior exactly.
        var prices = std.StringHashMap(f64).init(allocator);
        defer prices.deinit();
        for (lp.positions) |pos| {
            if (pos.shares <= 0) continue;
            if (svc.getCachedCandles(pos.symbol)) |cs| {
                defer cs.deinit();
                if (cs.data.len > 0) {
                    try prices.put(pos.symbol, cs.data[cs.data.len - 1].close);
                }
            }
        }

        live_pf_data = cli.buildPortfolioData(allocator, lp.portfolio, lp.positions, lp.syms, &prices, svc, as_of) catch |err| switch (err) {
            error.NoAllocations, error.SummaryFailed => {
                try cli.stderrPrint(io, "Error computing portfolio summary.\n");
                return;
            },
            else => return err,
        };

        ctx = try view.loadProjectionContext(
            io,
            va,
            portfolio_dir,
            live_pf_data.?.summary.allocations,
            live_pf_data.?.summary.total_value,
            lp.portfolio.totalCash(as_of),
            lp.portfolio.totalCdFaceValue(as_of),
            svc,
            events_enabled,
            as_of,
        );
    }

    // ── Optional actuals overlay ────────────────────────────────
    //
    // Requires `--as-of` (an as-of-resolved snapshot date). When the
    // user passes `--overlay-actuals` without `--as-of`, warn and
    // continue without the overlay; the overlay against today-as-now
    // is meaningless because the future hasn't happened yet.
    if (overlay_actuals) {
        if (!from_snapshot) {
            try cli.stderrPrint(io, "Note: --overlay-actuals requires --as-of; ignoring.\n");
        } else if (resolution) |r| {
            ctx.overlay_actuals = loadOverlayActuals(io, va, file_path, r.actual, today) catch |err| blk: {
                // Non-fatal — the projection still renders without
                // the overlay. Surface the error so the user can fix
                // their history dir but don't block the report.
                var buf: [256]u8 = undefined;
                const msg = std.fmt.bufPrint(&buf, "Note: could not load actuals overlay ({s}); rendering without it.\n", .{@errorName(err)}) catch "Note: could not load actuals overlay; rendering without it.\n";
                try cli.stderrPrint(io, msg);
                break :blk null;
            };
        }
    }

    const horizons = ctx.config.getHorizons();
    const confidence_levels = ctx.config.getConfidenceLevels();
    const comparison = ctx.comparison;

    try out.print("\n", .{});
    if (resolution) |r| {
        const source_label: []const u8 = switch (r.source) {
            .snapshot => "snapshot",
            .imported => "imported value",
        };
        try cli.printBold(out, color, "Projections (as of {f}, {s})\n", .{ r.actual, source_label });
    } else {
        try cli.printBold(out, color, "Projections ({s})\n", .{file_path});
    }
    try out.print("========================================\n", .{});

    // If auto-snapped, print a muted note so the user knows the
    // requested date wasn't an exact hit. The wording reflects the
    // resolution source — "nearest snapshot" vs "nearest imported
    // value" — so the user knows which file to update for finer
    // granularity.
    if (resolution) |r| {
        if (r.actual.days != r.requested.days) {
            const diff = r.requested.days - r.actual.days;
            const nearest_label: []const u8 = switch (r.source) {
                .snapshot => "nearest snapshot",
                .imported => "nearest imported value",
            };
            try cli.printFg(out, color, cli.CLR_MUTED, "(requested {f}; {s}: {f}, {d} day{s} earlier)\n", .{
                r.requested,
                nearest_label,
                r.actual,
                diff,
                fmt.dayPlural(diff),
            });
        }
        if (r.source == .imported) {
            try cli.printFg(out, color, cli.CLR_MUTED, "(bands use today's allocation scaled to the imported liquid total)\n", .{});
        }
    }
    try out.print("\n", .{});

    // Header row
    try cli.printFg(out, color, cli.CLR_MUTED, "{s: <32}{s: >8}{s: >9}{s: >9}{s: >10}{s: >9}\n", .{
        "", "1 Year", "3 Year", "5 Year", "10 Year", "Week",
    });

    // Build return rows via view model
    var spy_bufs: [5][16]u8 = undefined;
    var spy_label_buf: [32]u8 = undefined;
    const spy_row = view.buildReturnRow(
        view.fmtBenchmarkLabel(&spy_label_buf, stock_benchmark, ctx.stock_pct * 100),
        comparison.stock_returns,
        &spy_bufs,
        false,
    );

    var agg_bufs: [5][16]u8 = undefined;
    var agg_label_buf: [32]u8 = undefined;
    const agg_row = view.buildReturnRow(
        view.fmtBenchmarkLabel(&agg_label_buf, bond_benchmark, ctx.bond_pct * 100),
        comparison.bond_returns,
        &agg_bufs,
        false,
    );

    var bench_bufs: [5][16]u8 = undefined;
    const bench_row = view.buildReturnRow("Benchmark", comparison.benchmark_returns, &bench_bufs, true);

    var port_bufs: [5][16]u8 = undefined;
    const port_row = view.buildReturnRow("Your Portfolio", comparison.portfolio_returns, &port_bufs, true);

    const rows = [_]view.ReturnRow{ spy_row, agg_row, bench_row };
    for (rows) |row| {
        if (row.bold) try cli.setBold(out, color);
        try writeReturnRow(out, color, row);
        if (row.bold) try cli.reset(out, color);
    }

    try out.print("\n", .{});

    try cli.setBold(out, color);
    try writeReturnRow(out, color, port_row);
    try cli.reset(out, color);

    // Projected return (conservative estimate from benchmark analytics)
    {
        var buf: [16]u8 = undefined;
        const cell = view.fmtReturnCell(&buf, comparison.conservative_return);
        try cli.printFg(out, color, cli.CLR_MUTED, "{s: <32}{s: >8}\n", .{ "Projected return", cell.text });
    }

    // Target allocation note
    {
        var note_buf: [128]u8 = undefined;
        if (view.fmtAllocationNote(&note_buf, ctx.config.target_stock_pct, ctx.stock_pct)) |note| {
            try out.print("\n", .{});
            try cli.printIntent(out, color, note.style, "{s}\n", .{note.text});
        }
    }

    // ── Accumulation phase / Earliest retirement blocks ──────────
    try renderAccumulationBlock(out, color, va, ctx);
    try renderEarliestBlock(out, color, va, ctx, as_of);

    // ── Braille chart: median portfolio value ─────────────────────
    if (horizons.len > 0) {
        const last_idx = horizons.len - 1;
        if (ctx.data.bands[last_idx]) |b| {
            if (b.len >= 2) {
                try out.print("\n", .{});
                try cli.printBold(out, color, "Median Portfolio Value ({d}-Year, 99% withdrawal)\n\n", .{horizons[last_idx]});

                // Synthesize candles from median values
                const candles = try va.alloc(zfin.Candle, b.len);
                for (b, 0..) |bp, i| {
                    const v: f32 = @floatCast(bp.p50);
                    candles[i] = .{
                        .date = zfin.Date.fromYmd(2025, 1, 1).addDays(@intCast(i * 365)),
                        .open = v,
                        .high = v,
                        .low = v,
                        .close = v,
                        .adj_close = v,
                        .volume = 0,
                    };
                }

                var br = fmt.computeBrailleChart(va, candles, 80, 12, cli.CLR_POSITIVE, cli.CLR_NEGATIVE) catch null;
                if (br) |*chart| {
                    try fmt.writeBrailleAnsi(out, chart, color, cli.CLR_MUTED, true);
                    // Year axis instead of date axis
                    try cli.setFg(out, color, cli.CLR_MUTED);
                    try out.print("  Now", .{});
                    const end_label_buf = try std.fmt.allocPrint(va, "{d}yr", .{horizons[last_idx]});
                    const pad = if (chart.n_cols > 3 + end_label_buf.len) chart.n_cols - 3 - end_label_buf.len else 0;
                    for (0..pad) |_| try out.print(" ", .{});
                    try out.print("{s}\n", .{end_label_buf});
                    try cli.reset(out, color);
                }
            }
        }
    }

    // Overlay-actuals tip: the CLI's braille chart is single-series,
    // so the actuals overlay only renders in the TUI. Print a short
    // pointer so the user knows where to find it. (We do NOT gate on
    // ctx.overlay_actuals being non-null — even when the overlay was
    // requested but had no data, the user benefits from the tip.)
    if (overlay_actuals and from_snapshot) {
        try cli.printFg(out, color, cli.CLR_MUTED, "  (Overlay rendered in TUI only — run `zfin interactive`, set as-of with `d`, then press `o`.)\n", .{});
        try cli.printFg(out, color, cli.CLR_MUTED, "  Caveat: overlay tracks trajectory, not SWR validity.\n", .{});
    }

    // ── Terminal portfolio value ─────────────────────────────────
    try out.print("\n", .{});
    try cli.printBold(out, color, "Terminal Portfolio Value (nominal, at 99% withdrawal rate)\n", .{});

    try out.print("{s}\n", .{try view.buildHeaderRow(va, horizons, view.terminal_col_width)});

    const p_labels = [_][]const u8{ "Pessimistic (p10)", "Median (p50)", "Optimistic (p90)" };
    const p_styles = [_]view.StyleIntent{ .muted, .normal, .muted };
    for (p_labels, p_styles, 0..) |plabel, pstyle, pi| {
        const row = try view.buildPercentileRow(va, plabel, pi, ctx.data.bands, pstyle);
        try cli.printIntent(out, color, row.style, "{s}\n", .{row.text});
    }

    // ── Safe withdrawal table ──────────────────────────────────
    try out.print("\n", .{});
    try cli.printBold(out, color, "Safe Withdrawal (FIRECalc historical simulation)\n", .{});

    // Header row
    try out.print("{s}\n", .{try view.buildHeaderRow(va, horizons, view.withdrawal_col_width)});

    // Withdrawal rows
    for (confidence_levels, 0..) |conf, ci| {
        const wr_rows = try view.buildWithdrawalRows(va, conf, horizons, ctx.data.withdrawals, ci);
        try out.print("{s}\n", .{wr_rows.amount.text});
        try cli.printFg(out, color, cli.CLR_MUTED, "{s}\n", .{wr_rows.rate.text});
    }

    // Life events summary — both as-of and live modes resolve ages
    // against the reference date (`resolution.actual` if a snapshot
    // was loaded, otherwise `as_of` directly).
    {
        const events = ctx.config.getEvents();
        if (events.len > 0) {
            const ages_ref_date = if (resolution) |r| r.actual else as_of;
            const ages = ctx.config.currentAges(ages_ref_date);
            try out.print("\n", .{});
            try cli.printBold(out, color, "Life Events\n", .{});
            for (events) |*ev| {
                const line = try view.fmtEventLine(va, ev, &ages);
                try cli.printIntent(out, color, line.style, "{s}\n", .{line.text});
            }
        }
    }

    try out.print("\n", .{});
}

/// Key numbers extracted from a fully-built `ProjectionContext` for
/// email-header headline comparison. Bundles what `zfin compare`'s
/// attribution line needs alongside what the weekly review email's
/// "Projected Return" and "1st Year Withdrawal" rows cite.
pub const KeyMetrics = struct {
    /// The "conservative" trailing-returns estimate (MIN 3Y/5Y/10Y
    /// per position, weighted). Rendered under the label
    /// "Projected return" — matches the email's column header.
    projected_return: f64,
    /// Safe withdrawal amount at longest horizon × 99% confidence.
    /// This is the "retirement now, 1st year withdrawal" number the
    /// email cites.
    swr_99: f64,
    /// `swr_99 / total_value`. Rendered as a percent alongside the
    /// dollar amount for comparison sanity.
    swr_99_rate: f64,
};

fn extractKeyMetrics(ctx: view.ProjectionContext) KeyMetrics {
    const horizons = ctx.config.getHorizons();
    const longest = horizons.len - 1;
    const swr = ctx.data.withdrawals[ctx.data.ci_99 * horizons.len + longest];
    const rate = if (ctx.total_value > 0) swr.annual_amount / ctx.total_value else 0.0;
    return .{
        .projected_return = ctx.comparison.conservative_return,
        .swr_99 = swr.annual_amount,
        .swr_99_rate = rate,
    };
}

/// Build a `ProjectionContext` against a historical snapshot date.
///
/// Caller owns `snap_bundle_out.*` on success — it must outlive the
/// returned context because allocations borrow symbol strings from
/// the snapshot's backing buffer.
fn loadAsOfContext(
    io: std.Io,
    allocator: std.mem.Allocator,
    va: std.mem.Allocator,
    svc: *zfin.DataService,
    file_path: []const u8,
    portfolio_dir: []const u8,
    events_enabled: bool,
    requested_date: Date,
    resolution_out: *AsOfResolution,
    snap_bundle_out: *history.LoadedSnapshot,
) !view.ProjectionContext {
    resolution_out.* = resolveAsOfSnapshot(io, va, file_path, requested_date) catch |err| return err;
    const hist_dir = try history.deriveHistoryDir(va, file_path);
    snap_bundle_out.* = try history.loadSnapshotAt(io, allocator, hist_dir, resolution_out.actual);
    return try view.loadProjectionContextAsOf(
        io,
        va,
        portfolio_dir,
        &snap_bundle_out.snap,
        resolution_out.actual,
        svc,
        events_enabled,
    );
}

/// `--vs <DATE>` entry point: compare two projections side-by-side
/// with deltas. The "then" side is always a historical snapshot at
/// `vs_date`; the "now" side is either another historical snapshot
/// (when `now_from_snapshot` is true) or the live portfolio at
/// `now_date`.
///
/// Target audience is the weekly review email's header — the
/// "Projected Return" and "1st Year Withdrawal" rows with Δ columns.
/// For the full benchmark table / SWR grid / percentile bands, run
/// `zfin projections` and `zfin projections --as-of <DATE>` separately.
pub fn runCompare(
    io: std.Io,
    allocator: std.mem.Allocator,
    svc: *zfin.DataService,
    file_path: []const u8,
    events_enabled: bool,
    vs_date: Date,
    now_date: Date,
    now_from_snapshot: bool,
    color: bool,
    out: *std.Io.Writer,
) !void {
    var arena_state = std.heap.ArenaAllocator.init(allocator);
    defer arena_state.deinit();
    const va = arena_state.allocator();

    const result = computeKeyComparison(io, allocator, va, svc, file_path, events_enabled, vs_date, now_date, now_from_snapshot) catch |err| switch (err) {
        error.NoSnapshot, error.PortfolioLoadFailed => return,
        else => return err,
    };
    defer result.cleanup();

    try out.print("\n", .{});
    var then_buf: [10]u8 = undefined;
    var now_buf: [10]u8 = undefined;
    const then_str = std.fmt.bufPrint(&then_buf, "{f}", .{result.resolution.actual}) catch "????-??-??";
    const now_str = if (result.now_resolution) |nr| (std.fmt.bufPrint(&now_buf, "{f}", .{nr.actual}) catch "????-??-??") else "today";
    const days_between = if (result.now_resolution) |nr|
        nr.actual.days - result.resolution.actual.days
    else
        now_date.days - result.resolution.actual.days;

    try cli.printBold(out, color, "Projections comparison: {s} → {s} ({d} day{s})\n", .{
        then_str,
        now_str,
        days_between,
        if (days_between == 1) "" else "s",
    });

    // Snap notes for either endpoint, if applicable.
    if (result.resolution.actual.days != result.resolution.requested.days) {
        const diff = result.resolution.requested.days - result.resolution.actual.days;
        try cli.printFg(out, color, cli.CLR_MUTED, "(requested {f} for then; nearest snapshot: {s}, {d} day{s} earlier)\n", .{
            result.resolution.requested,
            then_str,
            diff,
            if (diff == 1) "" else "s",
        });
    }
    if (result.now_resolution) |nr| {
        if (nr.actual.days != nr.requested.days) {
            const diff = nr.requested.days - nr.actual.days;
            try cli.printFg(out, color, cli.CLR_MUTED, "(requested {f} for now; nearest snapshot: {s}, {d} day{s} earlier)\n", .{
                nr.requested,
                now_str,
                diff,
                if (diff == 1) "" else "s",
            });
        }
    }
    try out.print("\n", .{});

    try renderKeyComparisonRows(out, color, result.then, result.now);

    try cli.printFg(out, color, cli.CLR_MUTED, "\nFor the full benchmark + SWR tables run `zfin projections --as-of {s}` and `zfin projections{s}`.\n", .{
        then_str,
        if (result.now_resolution) |_| (try std.fmt.allocPrint(va, " --as-of {s}", .{now_str})) else "",
    });
    try out.print("\n", .{});
}

/// Shared key-metrics comparison used by both `projections --vs` and
/// `compare --projections`. Returns `then`/`now` metrics ready for
/// rendering, plus the snapshot resolutions for header rendering.
/// Caller must invoke `cleanup()` to release retained snapshots.
///
/// When `now_from_snapshot` is false (live mode), only `retained_then`
/// is populated. When true, both snapshots are retained and must be
/// cleaned up via `cleanup()`.
pub const KeyComparisonResult = struct {
    then: KeyMetrics,
    now: KeyMetrics,
    /// Resolution of the "then" snapshot. Always present.
    resolution: AsOfResolution,
    /// Resolution of the "now" snapshot. Null when now is live.
    now_resolution: ?AsOfResolution,
    retained_then: history.LoadedSnapshot,
    retained_now: ?history.LoadedSnapshot,
    retained_allocator: std.mem.Allocator,

    pub fn cleanup(self: KeyComparisonResult) void {
        var mut = self;
        mut.retained_then.deinit(self.retained_allocator);
        if (mut.retained_now) |*s| s.deinit(self.retained_allocator);
    }
};

pub fn computeKeyComparison(
    io: std.Io,
    allocator: std.mem.Allocator,
    va: std.mem.Allocator,
    svc: *zfin.DataService,
    file_path: []const u8,
    events_enabled: bool,
    vs_date: Date,
    now_date: Date,
    now_from_snapshot: bool,
) !KeyComparisonResult {
    const dir_end = if (std.mem.lastIndexOfScalar(u8, file_path, std.fs.path.sep)) |idx| idx + 1 else 0;
    const portfolio_dir = file_path[0..dir_end];

    // Load "then" snapshot first. If it doesn't exist we bail before
    // doing the (more expensive) "now" side.
    var then_resolution: AsOfResolution = undefined;
    var then_snap: history.LoadedSnapshot = undefined;
    const then_ctx = try loadAsOfContext(
        io,
        allocator,
        va,
        svc,
        file_path,
        portfolio_dir,
        events_enabled,
        vs_date,
        &then_resolution,
        &then_snap,
    );

    // Now side — either another snapshot or the live portfolio.
    if (now_from_snapshot) {
        var now_resolution: AsOfResolution = undefined;
        var now_snap: history.LoadedSnapshot = undefined;
        const now_ctx = loadAsOfContext(
            io,
            allocator,
            va,
            svc,
            file_path,
            portfolio_dir,
            events_enabled,
            now_date,
            &now_resolution,
            &now_snap,
        ) catch |err| {
            then_snap.deinit(allocator);
            return err;
        };

        return .{
            .then = extractKeyMetrics(then_ctx),
            .now = extractKeyMetrics(now_ctx),
            .resolution = then_resolution,
            .now_resolution = now_resolution,
            .retained_then = then_snap,
            .retained_now = now_snap,
            .retained_allocator = allocator,
        };
    }

    // Live "now" side — mirrors `run()`'s live path.
    var loaded = cli.loadPortfolio(io, allocator, file_path, now_date) orelse {
        then_snap.deinit(allocator);
        return error.PortfolioLoadFailed;
    };
    defer loaded.deinit(allocator);

    var prices = std.StringHashMap(f64).init(allocator);
    defer prices.deinit();
    for (loaded.positions) |pos| {
        if (pos.shares <= 0) continue;
        if (svc.getCachedCandles(pos.symbol)) |cs| {
            defer cs.deinit();
            if (cs.data.len > 0) {
                try prices.put(pos.symbol, cs.data[cs.data.len - 1].close);
            }
        }
    }

    var pf_data = cli.buildPortfolioData(allocator, loaded.portfolio, loaded.positions, loaded.syms, &prices, svc, now_date) catch |err| switch (err) {
        error.NoAllocations, error.SummaryFailed => {
            then_snap.deinit(allocator);
            try cli.stderrPrint(io, "Error computing portfolio summary.\n");
            return error.PortfolioLoadFailed;
        },
        else => {
            then_snap.deinit(allocator);
            return err;
        },
    };
    defer pf_data.deinit(allocator);

    const now_ctx = try view.loadProjectionContext(
        io,
        va,
        portfolio_dir,
        pf_data.summary.allocations,
        pf_data.summary.total_value,
        loaded.portfolio.totalCash(now_date),
        loaded.portfolio.totalCdFaceValue(now_date),
        svc,
        events_enabled,
        now_date,
    );

    return .{
        .then = extractKeyMetrics(then_ctx),
        .now = extractKeyMetrics(now_ctx),
        .resolution = then_resolution,
        .now_resolution = null,
        .retained_then = then_snap,
        .retained_now = null,
        .retained_allocator = allocator,
    };
}

/// Render the three comparison rows (projected return, SWR @99%, SWR
/// rate). Shared between `projections --vs` and any other caller that
/// wants to embed the same block (e.g. `compare --projections`).
pub fn renderKeyComparisonRows(
    out: *std.Io.Writer,
    color: bool,
    then: KeyMetrics,
    now: KeyMetrics,
) !void {
    try renderCompareRowPct(out, color, "Projected return:", then.projected_return, now.projected_return);
    try renderCompareRowMoney(out, color, "Safe withdrawal @99%:", then.swr_99, now.swr_99);
    try renderCompareRowPct(out, color, "  (as % of total)", then.swr_99_rate, now.swr_99_rate);
}

/// Render a "label: then → now    Δ" row for percentage values.
fn renderCompareRowPct(out: *std.Io.Writer, color: bool, label: []const u8, then_val: f64, now_val: f64) !void {
    const delta = now_val - then_val;
    var then_buf: [16]u8 = undefined;
    var now_buf: [16]u8 = undefined;
    var delta_buf: [16]u8 = undefined;
    const then_str = std.fmt.bufPrint(&then_buf, "{d:.2}%", .{then_val * 100.0}) catch "?";
    const now_str = std.fmt.bufPrint(&now_buf, "{d:.2}%", .{now_val * 100.0}) catch "?";
    const delta_str = std.fmt.bufPrint(&delta_buf, "{s}{d:.2}%", .{ if (delta >= 0) "+" else "", delta * 100.0 }) catch "?";

    try cli.printFg(out, color, cli.CLR_MUTED, "  {s:<22}  ", .{label});
    try cli.printFg(out, color, cli.CLR_MUTED, "{s: >10} → {s: >10}    ", .{ then_str, now_str });
    try cli.printGainLoss(out, color, delta, "{s: >10}\n", .{delta_str});
}

/// Render a "label: then → now    Δ" row for money values.
fn renderCompareRowMoney(out: *std.Io.Writer, color: bool, label: []const u8, then_val: f64, now_val: f64) !void {
    const delta = now_val - then_val;

    try cli.printFg(out, color, cli.CLR_MUTED, "  {s:<22}  ", .{label});
    try cli.printFg(out, color, cli.CLR_MUTED, "{f} → {f}    ", .{
        Money.from(then_val).padRight(10),
        Money.from(now_val).padRight(10),
    });
    try cli.printGainLoss(out, color, delta, "{f}\n", .{Money.from(delta).signed().padRight(12)});
}

/// Resolve the user's requested as-of date against the history
/// directory, accepting either a native snapshot or an
/// `imported_values.srf` row.
///
/// Thin adapter over `cli.resolveAsOfOrExplain` — the shared CLI
/// helper owns the exact-then-fallback resolution and the stderr
/// messaging. This wrapper just maps the error set to
/// `error.NoSnapshot` (projections-specific) and packs the source +
/// liquid fields into the local `AsOfResolution` shape.
///
/// Arena-allocates the intermediate `hist_dir` + filename strings;
/// pass a short-lived arena as `va`.
fn resolveAsOfSnapshot(
    io: std.Io,
    va: std.mem.Allocator,
    file_path: []const u8,
    requested: Date,
) !AsOfResolution {
    const hist_dir = try history.deriveHistoryDir(va, file_path);

    const resolved = cli.resolveAsOfOrExplain(io, va, hist_dir, requested) catch |err| switch (err) {
        error.NoDataAtOrBefore => return error.NoSnapshot,
        else => |e| {
            try cli.stderrPrint(io, "Error resolving as-of: ");
            try cli.stderrPrint(io, @errorName(e));
            try cli.stderrPrint(io, "\n");
            return error.NoSnapshot;
        },
    };

    return .{
        .requested = resolved.requested,
        .actual = resolved.actual,
        .source = resolved.source,
        .liquid = resolved.liquid,
    };
}

/// Load the merged history timeline (snapshots + imported_values),
/// filter to the [`as_of`, `today`] range, and produce an overlay
/// section. Caller passes an arena allocator so all intermediate
/// allocations are freed at the end of the request.
///
/// Returns null on a missing/empty history dir — that's a soft
/// failure (no overlay rendered, projection still works).
fn loadOverlayActuals(
    io: std.Io,
    arena: std.mem.Allocator,
    file_path: []const u8,
    as_of: Date,
    today: Date,
) !?view.OverlayActualsSection {
    var loaded = history.loadTimeline(io, arena, file_path) catch |err| switch (err) {
        // Missing/unreadable history dir → no overlay, no error.
        error.FileNotFound, error.NotDir, error.AccessDenied => return null,
        else => return err,
    };
    defer loaded.deinit();

    if (loaded.series.points.len == 0) return null;

    return try view.buildOverlayActuals(arena, loaded.series.points, as_of, today);
}

/// Write a return row using the view model, applying StyleIntent colors.
fn writeReturnRow(out: *std.Io.Writer, color: bool, row: view.ReturnRow) !void {
    try out.print("{s: <32}", .{row.label});
    try writeCell(out, color, row.one_year, 8);
    try writeCell(out, color, row.three_year, 9);
    try writeCell(out, color, row.five_year, 9);
    try writeCell(out, color, row.ten_year, 10);
    try writeCell(out, color, row.week, 9);
    try out.print("\n", .{});
}

fn writeCell(out: *std.Io.Writer, color: bool, cell: view.ReturnCell, width: usize) !void {
    switch (width) {
        8 => try cli.printIntent(out, color, cell.style, "{s: >8}", .{cell.text}),
        9 => try cli.printIntent(out, color, cell.style, "{s: >9}", .{cell.text}),
        10 => try cli.printIntent(out, color, cell.style, "{s: >10}", .{cell.text}),
        else => try cli.printIntent(out, color, cell.style, "{s}", .{cell.text}),
    }
}

/// Render the "Accumulation phase" block (driven by the user's
/// target retirement date — `retirement_age` / `retirement_at` —
/// or by the promoted cell from the earliest-retirement search when
/// only `target_spending` is configured).
///
/// Always emits the "Years until possible retirement" line — including
/// `none` for the already-retired case, where the entire block reduces
/// to that single line. When a retirement date is configured, the
/// median portfolio at retirement and the p10–p90 range follow,
/// computed from the longest-horizon percentile bands.
fn renderAccumulationBlock(out: *std.Io.Writer, color: bool, va: std.mem.Allocator, ctx: view.ProjectionContext) !void {
    try out.print("\n", .{});
    try cli.printBold(out, color, "Accumulation phase:\n", .{});

    var line_buf: [128]u8 = undefined;
    const parts = view.splitRetirementLine(&line_buf, ctx.retirement, &ctx.config);
    // Label stays neutral; only the value (date / "not feasible" /
    // "none") carries a style. This keeps "not feasible" loud
    // without making the entire row scream red.
    try out.print("  {s}", .{parts.label_text});
    try cli.printIntent(out, color, parts.value_style, "{s}\n", .{parts.value_text});

    // Contribution line — suppressed when both contribution and
    // accumulation are zero.
    if (try view.fmtContributionLine(va, ctx.config.annual_contribution, ctx.config.contribution_inflation_adjusted, ctx.retirement.accumulation_years)) |contrib| {
        try out.print("  {s}\n", .{contrib});
    }

    // Accumulation-phase stats: median + p10-p90 range at the
    // retirement boundary.
    if (ctx.accumulation) |acc| {
        try out.print("  Median portfolio at retirement:  {f}\n", .{Money.from(acc.median_at_retirement).trim()});
        try out.print("  Range (10th\u{2013}90th percentile):    {f} to {f}\n", .{
            Money.from(acc.p10_at_retirement).trim(),
            Money.from(acc.p90_at_retirement).trim(),
        });
    }
}

/// Render the "Earliest retirement" block (driven by the user's
/// target spending — `target_spending`).
///
/// Renders a grid of (confidence × horizon) cells, each showing the
/// earliest retirement date that sustains the target spending at that
/// confidence over that distribution horizon, or "—" when not feasible
/// within `max_accumulation_years`.
fn renderEarliestBlock(out: *std.Io.Writer, color: bool, va: std.mem.Allocator, ctx: view.ProjectionContext, as_of: zfin.Date) !void {
    const earliest = ctx.earliest orelse return;
    const target = ctx.config.target_spending orelse return;

    try out.print("\n", .{});
    const adj: []const u8 = if (ctx.config.target_spending_inflation_adjusted) "CPI-adjusted" else "nominal";
    try cli.printBold(out, color, "Earliest retirement (target spending: {f}/yr {s})\n", .{ Money.from(target).trim(), adj });

    const horizons = ctx.config.getHorizons();
    const confs = ctx.config.getConfidenceLevels();

    // Header row: blank label space + horizon column headers.
    const cell_width: usize = 14;
    const label_width: usize = 25;
    {
        var hdr: std.ArrayListUnmanaged(u8) = .empty;
        try hdr.appendNTimes(va, ' ', label_width);
        for (horizons) |h| {
            var hbuf: [16]u8 = undefined;
            const hlabel = view.fmtHorizonLabel(&hbuf, h);
            try hdr.appendNTimes(va, ' ', cell_width -| hlabel.len);
            try hdr.appendSlice(va, hlabel);
        }
        try cli.printFg(out, color, cli.CLR_MUTED, "{s}\n", .{hdr.items});
    }

    for (confs, 0..) |conf, ci| {
        const row = try view.buildEarliestRow(va, conf, horizons, earliest, ci, as_of);
        // Label
        try out.print("  {s}", .{row.label_text});
        // Pad label to label_width (we wrote 2 leading spaces + label, so pad to label_width - 2).
        const pad = if (label_width > 2 + row.label_text.len) label_width - 2 - row.label_text.len else 0;
        for (0..pad) |_| try out.print(" ", .{});
        // Cells
        for (row.cells) |cell| {
            const cellpad = if (cell_width > cell.text.len) cell_width - cell.text.len else 0;
            for (0..cellpad) |_| try out.print(" ", .{});
            try cli.printIntent(out, color, cell.style, "{s}", .{cell.text});
        }
        try out.print("\n", .{});
    }
}

// ── Tests ────────────────────────────────────────────────────
//
// The projections simulation and rendering are covered by the
// view-model tests in `src/views/projections.zig` and the analytics
// tests in `src/analytics/`. These tests focus on the CLI-surface
// behaviour that `run` is responsible for: as-of snapshot resolution,
// exact/nearest/miss branching, and error reporting.

const testing = std.testing;
const snapshot_model = @import("../models/snapshot.zig");
const snapshot = @import("snapshot.zig");

fn makeTestSvc() zfin.DataService {
    const config = zfin.Config{ .cache_dir = "/tmp" };
    return zfin.DataService.init(std.testing.io, testing.allocator, config);
}

fn writeFixtureSnapshot(
    io: std.Io,
    dir: std.Io.Dir,
    allocator: std.mem.Allocator,
    filename: []const u8,
    as_of: Date,
    liquid: f64,
) !void {
    const lots = [_]snapshot_model.LotRow{
        .{
            .kind = "lot",
            .symbol = "VTI",
            .lot_symbol = "VTI",
            .account = "Roth",
            .security_type = "Stock",
            .shares = 100,
            .open_price = 200,
            .cost_basis = 20_000,
            .value = liquid,
            .price = liquid / 100,
            .quote_date = as_of,
        },
    };
    const totals = [_]snapshot_model.TotalRow{
        .{ .kind = "total", .scope = "net_worth", .value = liquid },
        .{ .kind = "total", .scope = "liquid", .value = liquid },
        .{ .kind = "total", .scope = "illiquid", .value = 0 },
    };
    const snap: snapshot_model.Snapshot = .{
        .meta = .{
            .kind = "meta",
            .snapshot_version = 1,
            .as_of_date = as_of,
            .captured_at = 1_745_222_400,
            .zfin_version = "test",
            .stale_count = 0,
        },
        .totals = @constCast(&totals),
        .tax_types = &.{},
        .accounts = &.{},
        .lots = @constCast(&lots),
    };
    const rendered = try snapshot.renderSnapshot(allocator, snap);
    defer allocator.free(rendered);
    try dir.writeFile(io, .{ .sub_path = filename, .data = rendered });
}

/// Build a portfolio path inside `tmp` and return the joined string.
/// Caller owns the returned buffer.
fn makeTestPortfolioPath(io: std.Io, tmp: *std.testing.TmpDir, allocator: std.mem.Allocator) ![]u8 {
    const dir_path = try tmp.dir.realPathFileAlloc(io, ".", allocator);
    defer allocator.free(dir_path);
    return std.fs.path.join(allocator, &.{ dir_path, "portfolio.srf" });
}

test "resolveAsOfSnapshot: exact match returns actual == requested" {
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDirPath(io, "history");
    var hist_dir = try tmp.dir.openDir(io, "history", .{});
    defer hist_dir.close(io);

    const d = Date.fromYmd(2026, 3, 13);
    try writeFixtureSnapshot(io, hist_dir, testing.allocator, "2026-03-13-portfolio.srf", d, 1_000_000);

    const pf = try makeTestPortfolioPath(io, &tmp, testing.allocator);
    defer testing.allocator.free(pf);

    var arena = std.heap.ArenaAllocator.init(testing.allocator);
    defer arena.deinit();

    const res = try resolveAsOfSnapshot(std.testing.io, arena.allocator(), pf, d);
    try testing.expect(res.actual.eql(d));
    try testing.expect(res.requested.eql(d));
}

test "resolveAsOfSnapshot: no exact match snaps to earlier" {
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDirPath(io, "history");
    var hist_dir = try tmp.dir.openDir(io, "history", .{});
    defer hist_dir.close(io);

    const earlier = Date.fromYmd(2026, 3, 12);
    try writeFixtureSnapshot(io, hist_dir, testing.allocator, "2026-03-12-portfolio.srf", earlier, 1_000_000);

    const pf = try makeTestPortfolioPath(io, &tmp, testing.allocator);
    defer testing.allocator.free(pf);

    var arena = std.heap.ArenaAllocator.init(testing.allocator);
    defer arena.deinit();

    const requested = Date.fromYmd(2026, 3, 13);
    const res = try resolveAsOfSnapshot(std.testing.io, arena.allocator(), pf, requested);
    try testing.expect(res.actual.eql(earlier));
    try testing.expect(res.requested.eql(requested));
    try testing.expect(!res.actual.eql(res.requested));
}

test "resolveAsOfSnapshot: no earlier snapshot returns NoSnapshot" {
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDirPath(io, "history");
    var hist_dir = try tmp.dir.openDir(io, "history", .{});
    defer hist_dir.close(io);

    // Only a later snapshot exists — can't satisfy an earlier request.
    const later = Date.fromYmd(2026, 4, 1);
    try writeFixtureSnapshot(io, hist_dir, testing.allocator, "2026-04-01-portfolio.srf", later, 1_000_000);

    const pf = try makeTestPortfolioPath(io, &tmp, testing.allocator);
    defer testing.allocator.free(pf);

    var arena = std.heap.ArenaAllocator.init(testing.allocator);
    defer arena.deinit();

    const requested = Date.fromYmd(2026, 3, 13);
    const result = resolveAsOfSnapshot(std.testing.io, arena.allocator(), pf, requested);
    try testing.expectError(error.NoSnapshot, result);
}

test "resolveAsOfSnapshot: empty history dir returns NoSnapshot" {
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    try tmp.dir.createDirPath(io, "history");

    const pf = try makeTestPortfolioPath(io, &tmp, testing.allocator);
    defer testing.allocator.free(pf);

    var arena = std.heap.ArenaAllocator.init(testing.allocator);
    defer arena.deinit();

    const requested = Date.fromYmd(2026, 3, 13);
    const result = resolveAsOfSnapshot(std.testing.io, arena.allocator(), pf, requested);
    try testing.expectError(error.NoSnapshot, result);
}

test "run: as_of with no snapshots returns without error (stderr-only)" {
    const io = std.testing.io;
    // No history dir at all. `run` prints a stderr hint via
    // `resolveAsOfSnapshot` and returns — should NOT propagate the
    // error to the caller (exit code stays 0 from the CLI dispatch).
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    var svc = makeTestSvc();
    defer svc.deinit();

    const pf = try makeTestPortfolioPath(io, &tmp, testing.allocator);
    defer testing.allocator.free(pf);

    var buf: [4096]u8 = undefined;
    var stream = std.Io.Writer.fixed(&buf);

    const d = Date.fromYmd(2026, 3, 13);
    try run(io, testing.allocator, &svc, pf, false, d, true, d, false, false, &stream);

    // No body output because the resolution failed — the stderr
    // message is swallowed by `cli.stderrPrint` and doesn't land in
    // `stream`. This guarantees the error-path returns cleanly.
    const out = stream.buffered();
    try testing.expectEqual(@as(usize, 0), out.len);
}

test "run: as_of with matching snapshot produces body output" {
    const io = std.testing.io;
    // End-to-end smoke test. With no cached candles, benchmark rows
    // will be `--` and portfolio returns will be empty, but the
    // rendering pipeline should still produce a complete header +
    // tables without panicking.
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    var svc = makeTestSvc();
    defer svc.deinit();

    try tmp.dir.createDirPath(io, "history");
    var hist_dir = try tmp.dir.openDir(io, "history", .{});
    defer hist_dir.close(io);

    const d = Date.fromYmd(2026, 3, 13);
    try writeFixtureSnapshot(io, hist_dir, testing.allocator, "2026-03-13-portfolio.srf", d, 1_000_000);

    const pf = try makeTestPortfolioPath(io, &tmp, testing.allocator);
    defer testing.allocator.free(pf);

    var buf: [32_768]u8 = undefined;
    var stream = std.Io.Writer.fixed(&buf);
    try run(io, testing.allocator, &svc, pf, false, d, true, d, false, false, &stream);

    const out = stream.buffered();
    // Header should call out the as-of date explicitly.
    try testing.expect(std.mem.indexOf(u8, out, "as of 2026-03-13") != null);
    // Benchmark + withdrawal tables still render even with missing candles.
    try testing.expect(std.mem.indexOf(u8, out, "Safe Withdrawal") != null);
    try testing.expect(std.mem.indexOf(u8, out, "Terminal Portfolio Value") != null);
}

test "run: as_of auto-snap surfaces muted 'nearest' note" {
    const io = std.testing.io;
    var tmp = std.testing.tmpDir(.{});
    defer tmp.cleanup();
    var svc = makeTestSvc();
    defer svc.deinit();

    try tmp.dir.createDirPath(io, "history");
    var hist_dir = try tmp.dir.openDir(io, "history", .{});
    defer hist_dir.close(io);

    const actual = Date.fromYmd(2026, 3, 12);
    try writeFixtureSnapshot(io, hist_dir, testing.allocator, "2026-03-12-portfolio.srf", actual, 1_000_000);

    const pf = try makeTestPortfolioPath(io, &tmp, testing.allocator);
    defer testing.allocator.free(pf);

    var buf: [32_768]u8 = undefined;
    var stream = std.Io.Writer.fixed(&buf);

    const requested = Date.fromYmd(2026, 3, 13);
    try run(io, testing.allocator, &svc, pf, false, requested, true, requested, false, false, &stream);

    const out = stream.buffered();
    try testing.expect(std.mem.indexOf(u8, out, "as of 2026-03-12") != null);
    try testing.expect(std.mem.indexOf(u8, out, "(requested 2026-03-13") != null);
    try testing.expect(std.mem.indexOf(u8, out, "nearest snapshot: 2026-03-12") != null);
    // 1 day earlier → singular "day", not "days"
    try testing.expect(std.mem.indexOf(u8, out, "1 day earlier") != null);
}

test "renderCompareRowPct: positive delta renders with + sign" {
    var buf: [256]u8 = undefined;
    var w: std.Io.Writer = .fixed(&buf);
    try renderCompareRowPct(&w, false, "Stocks", 0.50, 0.65);
    const out = w.buffered();
    try testing.expect(std.mem.indexOf(u8, out, "Stocks") != null);
    try testing.expect(std.mem.indexOf(u8, out, "50.00%") != null);
    try testing.expect(std.mem.indexOf(u8, out, "65.00%") != null);
    try testing.expect(std.mem.indexOf(u8, out, "+15.00%") != null);
}

test "renderCompareRowPct: negative delta has no + sign" {
    var buf: [256]u8 = undefined;
    var w: std.Io.Writer = .fixed(&buf);
    try renderCompareRowPct(&w, false, "Bonds", 0.40, 0.30);
    const out = w.buffered();
    try testing.expect(std.mem.indexOf(u8, out, "40.00%") != null);
    try testing.expect(std.mem.indexOf(u8, out, "30.00%") != null);
    try testing.expect(std.mem.indexOf(u8, out, "-10.00%") != null);
}

test "renderCompareRowMoney: positive delta" {
    var buf: [256]u8 = undefined;
    var w: std.Io.Writer = .fixed(&buf);
    try renderCompareRowMoney(&w, false, "Net Worth", 100_000, 110_000);
    const out = w.buffered();
    try testing.expect(std.mem.indexOf(u8, out, "Net Worth") != null);
    try testing.expect(std.mem.indexOf(u8, out, "$100,000") != null);
    try testing.expect(std.mem.indexOf(u8, out, "$110,000") != null);
}

test "renderCompareRowMoney: zero delta" {
    var buf: [256]u8 = undefined;
    var w: std.Io.Writer = .fixed(&buf);
    try renderCompareRowMoney(&w, false, "Cash", 50_000, 50_000);
    const out = w.buffered();
    try testing.expect(std.mem.indexOf(u8, out, "Cash") != null);
    try testing.expect(std.mem.indexOf(u8, out, "$50,000") != null);
}

test "renderCompareRowPct: no ANSI when color=false" {
    var buf: [256]u8 = undefined;
    var w: std.Io.Writer = .fixed(&buf);
    try renderCompareRowPct(&w, false, "X", 0.1, 0.2);
    try testing.expect(std.mem.indexOf(u8, w.buffered(), "\x1b[") == null);
}