zigler

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(<%=Zig.Target.for_builder()%>);
    const optimize = b.standardOptimizeOption(.{});

    const erl_nif = b.createModule(
        .{
            .root_source_file = .{.cwd_relative = "<%= Path.join(@beam_dir, "erl_nif.zig")%>"},
            .imports = &[_]std.Build.Module.Import{},
        });

    erl_nif.addSystemIncludePath(
        .{.cwd_relative = "<%= :code.root_dir() %>/erts-<%= :erlang.system_info(:version) %>/include"}
    );


    <%= if windows_shim_dir = assigns[:windows_shim_dir] do %>
    erl_nif.addSystemIncludePath(
        .{.cwd_relative = "<%= windows_shim_dir %>"}
    );
    <% end %>

    const beam = b.createModule(
        .{
            .root_source_file = .{.cwd_relative = "<%= Path.join(@beam_dir, "beam.zig")%>"},
            .imports = &[_]std.Build.Module.Import{.{
                .name = "erl_nif",
                .module = erl_nif
            }}
        });

    const attributes = b.createModule(
        .{
            .root_source_file = .{.cwd_relative = "attributes.zig"},
            .imports = &[_]std.Build.Module.Import{}
        });

    <%= for {name, path, deps} <- @packages do %>
    const <%= name %> = b.createModule(
        .{
            .root_source_file = .{.cwd_relative = "<%= path %>"},
            .imports = &[_]std.Build.Module.Import{
                <%= for dep <- deps do %>
                .{
                    .name = "<%= dep %>",
                    .module = <%= dep %>
                },
                <% end %>
            }
        });
    <% end %>

    <% module_list = Enum.map(@packages, fn {name, _, _} -> "#{name}" end) %>

    const nif = b.createModule(.{
        .root_source_file = .{.cwd_relative = "<%= @zig_code_path %>"},
        .imports = &[_]std.Build.Module.Import{.{
            .name = "erl_nif",
            .module = erl_nif
        }, .{
            .name = "beam",
            .module = beam
        }, .{
            .name = "attributes",
            .module = attributes
        }
        <%= for module <- module_list do %>
        , .{
            .name = "<%= module %>",
            .module = <%= module %>
        }
        <% end %>
        },
        .target = target
    });

    <%= if @c do %>
    <%= for lib <- @c.link_lib do %>
        <%= case lib do %>
        <% {:system, lib} -> %>
    nif.linkSystemLibrary("<%= lib %>", .{});
        <% lib -> %>
    nif.addObjectFile(.{.cwd_relative = "<%= lib %>"});
      <% end %>
    <% end %>
    <% end %>

    <%= for include_dir <- @c.include_dirs do %>
    nif.addIncludePath(.{.cwd_relative = "<%= include_dir %>"});
    <% end %>

    <%= for library_dir <- @c.library_dirs do %>
    nif.addLibraryPath(.{.cwd_relative = "<%= library_dir %>"});
    <% end %>

    <%= for {src, src_opts} <- @c.src do %>
    <% ccompileparams = Enum.map_join(src_opts, ", ", &~s("#{&1}")) %>
    nif.addCSourceFile(.{.file = .{.cwd_relative = "<%= src %>"}, .flags = &[_][]const u8{<%= ccompileparams %>}});
    <% end %>

    const lib = b.addSharedLibrary(.{
        .name = "<%= @module %>",
        .root_source_file = .{ .src_path = .{ .owner = b, .sub_path = "module.zig"} },
        .version = .{.major = <%= @version.major %>,
                     .minor = <%= @version.minor %>,
                     .patch = <%= @version.patch %>},
        .target = target,
        .optimize = optimize,
    });

    lib.linkLibC();

    lib.linker_allow_shlib_undefined = true;

    lib.root_module.addImport("erl_nif", erl_nif);
    lib.root_module.addImport("beam", beam);
    lib.root_module.addImport("nif", nif);

    b.installArtifact(lib);
}