const std = @import("std");
const elfo = @import("elfo.zig");

pub fn main(init: std.process.Init.Minimal) !void {
    var args = init.args.iterate();
    _ = args.skip();
    const subject = args.next() orelse "./study-samples/frog";

    std.debug.print("arg: {s}\n", .{subject});

    var debug_alloc: std.heap.DebugAllocator(.{}) = .init;
    const alloc = debug_alloc.allocator();

    var threaded: std.Io.Threaded = .init(alloc, .{
        .argv0 = .init(init.args),
        .environ = init.environ,
    });
    defer threaded.deinit();
    const io = threaded.io();

    var child = try std.process.spawn(io, .{
        .argv = &.{subject},
        .stdout = .pipe,
        .stdin = .inherit,
    });

    const buf = try alloc.alloc(u8, 0x400);
    defer alloc.free(buf);
    _ = try child.stdout.?.readStreaming(io, &.{buf});

    std.debug.print("spawned child: {any}\n", .{child});

    var child_fut = io.async(std.process.Child.wait, .{ &child, io });
    const child_out = try child_fut.await(io);
    std.debug.print("stdout: {s}\n", .{buf});

    {
        var buffer: [64]u8 = undefined;
        const stderr = try io.lockStderr(&buffer, .escape_codes);
        defer io.unlockStderr();
        const term = stderr.terminal();
        try elfo.printHexdump(u8, term.writer, term, buf, 0);
    }

    std.debug.print("waited term: {any}\n", .{child_out});
}