const std = @import("std");

const log = std.log.scoped(.exe);
const Context = @import("main.zig").Context;
const fs = @import("fs.zig");

pub fn run_pandoc(ctx: *Context) !void {
    ctx.progress_start("Processing markdown files");
    defer ctx.progress_end();

    for (ctx.markdown.items) |page| {
        const source_path = try std.fs.path.join(ctx.allocator(), &.{ Context.params.PAGE_PATH, page });
        defer ctx.allocator().free(source_path);
        const target_path = try fs.replace_extension(ctx.allocator(), source_path, "htm");
        defer ctx.allocator().free(target_path);

        const f = try fs.FileSwapper.createAt(ctx.allocator(), target_path);
        defer f.close();

        try f.writer().print(
            \\<!-- Generated file, you may edit and discard {s} :) -->
            \\
        ,
            .{page},
        );

        try capture_stdout(ctx, &.{
            Context.params.PANDOC,
            "--from",
            "markdown+wikilinks_title_after_pipe+autolink_bare_uris",
            "--to",
            "html5",
            "--lua-filter",
            // TODO: embed the preproc filter
            Context.params.PANDOC_PREPROC,
            "--strip-comments",
            "--output=-",
            source_path,
        }, f.writer().any());
    }

    log.info("Processed {d} markdown files.", .{ctx.markdown.items.len});
}

pub fn capture_stdout(ctx: *Context, argv: []const []const u8, buf: std.io.AnyWriter) !void {
    const command = try std.mem.join(ctx.allocator(), " ", argv);
    defer ctx.allocator().free(command);
    const label = try std.fmt.allocPrint(ctx.allocator(), "running {s}", .{command});
    defer ctx.allocator().free(label);

    ctx.progress_start(label);
    defer ctx.progress_end();

    var p = std.process.Child.init(argv, std.heap.page_allocator);
    p.stdout_behavior = .Pipe;
    p.progress_node = ctx.progress_nodes.getLast();

    try p.spawn();

    try buf.writeFile(p.stdout.?);

    const result = try p.wait();
    _ = result;
}