const std = @import("std");

pub fn build(b: *std.Build) void {
    const optimize = b.standardOptimizeOption(.{});
    const target = b.standardTargetOptions(.{});

    // build-time IO, only used to slurp the grammars' highlights.scm queries.
    var threaded: std.Io.Threaded = .init(b.allocator, .{});
    defer threaded.deinit();
    const io = threaded.io();

    // -Dtrace: make the e2e runner print the captured screen state (after each
    //   pump/waitFor and on every assertion) so failures can be inspected live.
    //   Usage: `zig build test -Dtrace`.
    const trace = b.option(bool, "trace", "print captured tty/screen state during e2e tests") orelse false;

    const exe = b.addExecutable(.{
        .name = "pardes",
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .root_source_file = b.path("main.zig"),
        }),
    });
    const tests = b.addExecutable(.{
        .name = "pardes-e2e",
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .root_source_file = b.path("tests.zig"),
            .link_libc = true,
        }),
    });

    // ghostty-vt and vaxis both depend on uucode, but Zig 0.16 forbids the
    // same source file from belonging to two modules, so they can't each have
    // their own uucode instance. We build a single uucode module here (with our
    // own uucode_config.zig) and hand it to both.
    //
    // Our config matches ghostty's exactly except the tables are `.unpacked`;
    // see uucode_config.zig for why that's required on Zig 0.16.
    const uucode_config = b.path("uucode_config.zig");
    const uucode_tables = b.dependency("uucode", .{
        .target = target,
        .optimize = optimize,
        .build_config_path = uucode_config,
    }).namedLazyPath("tables.zig");
    const uucode_mod = b.dependency("uucode", .{
        .target = target,
        .optimize = optimize,
        .build_config_path = uucode_config,
        .tables_path = uucode_tables,
    }).module("uucode");

    // vaxis is built with `external_uucode = true` so it skips its built-in
    // uucode dependency and lets us wire one in.
    const vaxis_dep = b.dependency("vaxis", .{
        .target = target,
        .optimize = optimize,
        .external_uucode = true,
    });
    const vaxis_mod = vaxis_dep.module("vaxis");

    // You'll want to use a lazy dependency here so that ghostty is only
    // downloaded if you actually need it.
    if (b.lazyDependency("ghostty", .{
        // Setting simd to false will force a pure static build that
        // doesn't even require libc, but it has a significant performance
        // penalty. If your embedding app requires libc anyway, you should
        // always keep simd enabled.
        // .simd = false,
    })) |dep| {
        // Accessing ghostty's modules runs its build(), which (because vaxis is
        // a shared dependency, deduplicated to the same module) wires ghostty's
        // own uucode into vaxis. We undo that below by overriding both imports
        // with ours — order matters, so this must happen after this point.
        const ghostty_vt = dep.module("ghostty-vt");
        ghostty_vt.addImport("uucode", uucode_mod);
        exe.root_module.addImport("ghostty-vt", ghostty_vt);
        // The e2e test harness parses the app's pty output with its own ghostty
        // terminal (reads the 2D screen grid, not raw bytes), so it needs the
        // same module.
        tests.root_module.addImport("ghostty-vt", ghostty_vt);
    }

    // Override uucode on vaxis last, so it wins over ghostty's build() above.
    vaxis_mod.addImport("uucode", uucode_mod);
    exe.root_module.addImport("vaxis", vaxis_mod);

    // zstbi: C (stb_image)-backed image decoder for the image-viewer panes. We use
    // it instead of zigimg because zigimg's pure-Zig decoder crashes the Zig 0.16
    // compiler here; stb_image is plain C (extern fns), so it compiles fine, decodes
    // every common format, and offers downscaling. Its module ("root") carries the
    // C source + include path + libc, so importing it is all that's needed.
    const zstbi_mod = b.dependency("zstbi", .{ .target = target, .optimize = optimize }).module("root");
    exe.root_module.addImport("zstbi", zstbi_mod);

    // tree-sitter syntax highlighting for file panes: the Zig bindings + C runtime
    // (the `tree-sitter` module), each grammar's parser.c linked as a static lib,
    // and its highlights.scm read at build time into the `ts_queries` options module.
    const tree_sitter = b.dependency("tree_sitter", .{ .target = target, .optimize = optimize });
    exe.root_module.addImport("tree-sitter", tree_sitter.module("tree_sitter"));

    const Grammar = struct {
        name: []const u8,
        dep: []const u8,
        src: []const u8 = "src",
        scanner: bool = false,
        query: []const u8 = "queries/highlights.scm",
        local_query: ?[]const u8 = null,
    };
    const grammars = [_]Grammar{
        .{ .name = "ada", .dep = "ts_ada" },
        .{ .name = "bash", .dep = "ts_bash", .scanner = true },
        .{ .name = "c", .dep = "ts_c" },
        .{ .name = "c_sharp", .dep = "ts_c_sharp", .scanner = true },
        .{ .name = "clojure", .dep = "ts_clojure" },
        .{ .name = "cpp", .dep = "ts_cpp", .scanner = true },
        .{ .name = "css", .dep = "ts_css", .scanner = true },
        .{ .name = "elixir", .dep = "ts_elixir", .scanner = true },
        .{ .name = "erlang", .dep = "ts_erlang", .scanner = true },
        .{ .name = "fortran", .dep = "ts_fortran", .scanner = true },
        .{ .name = "go", .dep = "ts_go" },
        .{ .name = "haskell", .dep = "ts_haskell", .scanner = true },
        .{ .name = "html", .dep = "ts_html", .scanner = true },
        .{ .name = "java", .dep = "ts_java" },
        .{ .name = "javascript", .dep = "ts_javascript", .scanner = true },
        .{ .name = "json", .dep = "ts_json" },
        .{ .name = "kotlin", .dep = "ts_kotlin", .scanner = true },
        .{ .name = "ocaml", .dep = "ts_ocaml", .src = "grammars/ocaml/src", .scanner = true },
        .{ .name = "pascal", .dep = "ts_pascal" },
        .{ .name = "php", .dep = "ts_php", .src = "php/src", .scanner = true },
        .{ .name = "powershell", .dep = "ts_powershell", .scanner = true },
        .{ .name = "python", .dep = "ts_python", .scanner = true },
        .{ .name = "ruby", .dep = "ts_ruby", .scanner = true },
        .{ .name = "rust", .dep = "ts_rust", .scanner = true },
        .{ .name = "scala", .dep = "ts_scala", .scanner = true },
        .{ .name = "zig", .dep = "ts_zig" },
    };
    const ts_queries = b.addOptions();
    inline for (grammars) |g| {
        const dep = b.dependency(g.dep, .{});
        const query_path = if (g.local_query) |p| b.path(p) else dep.path(g.query);
        const query = std.Io.Dir.cwd().readFileAlloc(io, query_path.getPath(b), b.allocator, .limited(0x100000)) catch @panic("read " ++ g.name ++ " highlights");
        ts_queries.addOption([]const u8, g.name ++ "_highlights", query);

        const lib = b.addLibrary(.{
            .name = "tree-sitter-" ++ g.name,
            .root_module = b.createModule(.{ .target = target, .optimize = optimize, .link_libc = true }),
            .linkage = .static,
        });
        lib.root_module.addCSourceFile(.{ .file = dep.path(g.src ++ "/parser.c") });
        if (g.scanner) lib.root_module.addCSourceFile(.{ .file = dep.path(g.src ++ "/scanner.c") });
        lib.root_module.addIncludePath(dep.path(g.src));
        exe.root_module.linkLibrary(lib);
    }
    exe.root_module.addOptions("ts_queries", ts_queries);

    // Install the exe so `zig build` (and `zig build install`) produces it in
    // zig-out/bin for global install, not just as a hidden dep of `run`/`test`.
    b.installArtifact(exe);

    const run_exe = b.addRunArtifact(exe);

    const run = b.step("run", "descend to the pardes");
    run.dependOn(&run_exe.step);

    // tutor_gen: a separate binary that parses tutor.txt and writes
    // tutor_cases.zig (a file of `test` blocks, one per practice block).
    // `zig build tutor-gen` runs it; the unit-test step depends on the output.
    const tutor_gen = b.addExecutable(.{
        .name = "tutor-gen",
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .root_source_file = b.path("tutor_gen.zig"),
        }),
    });
    const run_tutor_gen = b.addRunArtifact(tutor_gen);
    run_tutor_gen.addArg("tutor.txt");
    const tutor_cases_lazy = run_tutor_gen.addOutputFileArg("tutor_cases.zig");
    const tutor_gen_step = b.step("tutor-gen", "regenerate tutor_cases.zig from tutor.txt");
    tutor_gen_step.dependOn(&run_tutor_gen.step);

    const run_tests = b.addRunArtifact(tests);
    run_tests.addArtifactArg(exe);

    // Expose build-time flags (e.g. -Dtrace) to the test runner as an importable
    // `config` module. tests.zig reads `config.trace` and hands it to the harness.
    const test_opts = b.addOptions();
    test_opts.addOption(bool, "trace", trace);
    tests.root_module.addOptions("config", test_opts);

    const test_step = b.step("test", "run deterministic tests");
    test_step.dependOn(&run_tests.step);

    // Unit tests for the pure modal-editing math (modal.zig has no vaxis/ghostty
    // deps, so `zig test` on it is fast and needs no wired-in modules).
    const unit_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .root_source_file = b.path("modal.zig"),
        }),
    });
    const run_unit = b.addRunArtifact(unit_tests);
    const unit_step = b.step("unit-test", "run modal.zig unit tests");
    unit_step.dependOn(&run_unit.step);
    test_step.dependOn(&run_unit.step);

    // petscii.zig is likewise pure (std only) — fold its matcher tests into both
    // the unit-test and the umbrella test step.
    const petscii_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .root_source_file = b.path("petscii.zig"),
        }),
    });
    const run_petscii = b.addRunArtifact(petscii_tests);
    unit_step.dependOn(&run_petscii.step);
    test_step.dependOn(&run_petscii.step);

    // Tutor practice blocks as unit tests: a second `zig test` target over the
    // generated tutor_cases.zig (which imports modal.zig). Depends on tutor-gen
    // so the file is (re)generated first.
    const tutor_tests = b.addTest(.{
        .root_module = b.createModule(.{
            .target = target,
            .optimize = optimize,
            .root_source_file = tutor_cases_lazy,
        }),
    });
    // The generated cases `@import("modal")` (a module name, not a relative
    // path, since the generated file lives in the cache dir, not next to modal.zig).
    const modal_for_tutor = b.createModule(.{
        .target = target,
        .optimize = optimize,
        .root_source_file = b.path("modal.zig"),
    });
    tutor_tests.root_module.addImport("modal", modal_for_tutor);
    const run_tutor = b.addRunArtifact(tutor_tests);
    const tutor_step = b.step("tutor-test", "run the tutor practice-block tests");
    tutor_step.dependOn(&run_tutor.step);
    test_step.dependOn(&run_tutor.step);
}