anzi/examples/random_sgr.zig

const std = @import("std");

const anzi = @import("anzi");

var done: bool = false;

fn signal(_: c_int) callconv(.C) void {
    done = true;
}

var column: u8 = 0;
var line: u8 = 0;

fn nextColumn() u8 {
    const c = column;
    column = (column + 7) % 80;
    return c + 1;
}

fn nextLine() u8 {
    const l = line;
    line = (line + 27) % 24;
    return l + 1;
}

var red: u8 = 0;
var green: u8 = 0;
var blue: u8 = 0;

inline fn nextRed() u8 {
    const r = red;
    red +%= 31;
    return r;
}

inline fn nextGreen() u8 {
    const g = green;
    green +%= 43;
    return g;
}

inline fn nextBlue() u8 {
    const b = blue;
    blue +%= 67;
    return b;
}

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const alloc = gpa.allocator();

    const action = std.os.Sigaction{
        .handler = .{
            .handler = signal,
        },
        .flags = 0,
        .mask = std.os.empty_sigset,
    };

    try std.os.sigaction(std.os.SIG.INT, &action, null);

    var generator = std.rand.DefaultPrng.init(@intCast(std.time.timestamp()));
    const random = generator.random();

    const a = anzi.ANSI(.{});

    std.debug.print("preparing buffer...\n", .{});

    const buffer = try alloc.alloc(u8, 1024 * 1024 * 1024);
    defer alloc.free(buffer);

    var fbs = std.io.fixedBufferStream(buffer);

    {
        const writer = fbs.writer();

        try writer.print("{}{}", .{
            a.ScreenMode{ .mode = .alternate_screen_save_cursor_clear_enter, .action = .set },
            a.ScreenMode{ .mode = .cursor_visible, .action = .reset },
        });
        errdefer {
            writer.print("{}{}", .{
                a.ScreenMode{ .mode = .cursor_visible, .action = .set },
                a.ScreenMode{ .mode = .alternate_screen_save_cursor_clear_enter, .action = .reset },
            }) catch unreachable;
        }

        try a.Erase.entireScreen.write(writer);

        var index: usize = 0;
        while (!done and index < 10000) : (index += 1) {
            // try (a.ScreenMode{ .mode = .synchronized_output, .action = .set }).write(writer);
            for (1..80) |_| {
                for (1..24) |_| {
                    try (a.CursorMove{
                        .to = .{
                            .column = random.intRangeAtMost(u8, 1, 80),
                            .line = random.intRangeAtMost(u8, 1, 24),
                        },
                    }).write(writer);
                    try (a.GraphicsRenditions{
                        .graphics = &[_]a.GraphicsRenditions.GraphicsRendition{
                            .{
                                .color = .{
                                    .layer = .foreground,
                                    .color = .{
                                        .colorRGB = .{
                                            .red = random.int(u8),
                                            .green = random.int(u8),
                                            .blue = random.int(u8),
                                        },
                                    },
                                },
                            },
                            .{
                                .color = .{
                                    .layer = .background,
                                    .color = .{
                                        .colorRGB = .{
                                            .red = random.int(u8),
                                            .green = random.int(u8),
                                            .blue = random.int(u8),
                                        },
                                    },
                                },
                            },
                        },
                    }).write(writer);
                    try writer.writeByte('J');
                }
            }
            // try (a.ScreenMode{ .mode = .synchronized_output, .action = .reset }).write(writer);
        }
        try a.reset.write(writer);
        try writer.print("{}{}", .{
            a.ScreenMode{ .mode = .cursor_visible, .action = .set },
            a.ScreenMode{ .mode = .alternate_screen_save_cursor_clear_enter, .action = .reset },
        });
    }

    var elapsed: u64 = undefined;
    const written = fbs.getWritten();

    {
        const stdout = std.io.getStdOut();
        const writer = stdout.writer();

        var iter = std.mem.window(u8, written, 4 * 1024 * 1024, 4 * 1024 * 1024);

        std.debug.print("starting to send data...\n", .{});

        var timer = try std.time.Timer.start();

        while (iter.next()) |buf| {
            try writer.writeAll(buf);
        }

        elapsed = timer.read();

        std.debug.print("finished sending data...\n", .{});
    }

    const units = [_]struct {
        name: []const u8,
        factor: u64,
    }{
        .{ .name = "y", .factor = 365 * std.time.ns_per_day },
        .{ .name = "w", .factor = std.time.ns_per_week },
        .{ .name = "d", .factor = std.time.ns_per_day },
        .{ .name = "h", .factor = std.time.ns_per_hour },
        .{ .name = "m", .factor = std.time.ns_per_min },
        .{ .name = "s", .factor = std.time.ns_per_s },
        .{ .name = "ms", .factor = std.time.ns_per_ms },
        .{ .name = "µs", .factor = std.time.ns_per_us },
        .{ .name = "ns", .factor = 1 },
    };

    var i: usize = 0;
    for (units) |unit| {
        if (elapsed > unit.factor) {
            if (i > 0) std.debug.print(" ", .{});
            const r = elapsed % unit.factor;
            const x = (elapsed - r) / unit.factor;
            std.debug.print("{d}{s}", .{ x, unit.name });
            elapsed = r;
            i += 1;
        }
    }

    std.debug.print("\n", .{});
    std.debug.print("{d}\n", .{written.len});
}