const std = @import("std");
const Allocator = std.mem.Allocator;

const DeclarationKind = enum {
    normal,
    @"opaque",
    import, // Assumed to be normal, but external
};

const Declarations = std.StringArrayHashMap(DeclarationKind);
const max_size = 5000000;

// The header type we'll parse from JSON. Fields are only included as needed.
// practice, etc.
const Header = struct {
    defines: []Define,
    typedefs: []Typedef,
    enums: []Enum,
    structs: []const Struct,
    functions: []Function,

    const Define = struct {
        name: []const u8,
        content: ?[]const u8 = null,
        is_internal: bool,
        conditionals: []const Conditional = &.{},
    };

    const Typedef = struct {
        name: []const u8,
        type: Type,
        conditionals: []const Conditional = &.{},
    };

    const Enum = struct {
        name: []const u8,
        storage_type: StorageType = .{ .declaration = .int },
        is_flags_enum: bool,
        elements: []const Element,
        is_internal: bool,
        conditionals: []const Conditional = &.{},

        const Element = struct {
            name: []const u8,
            value: i64,
            is_count: bool,
            is_internal: bool,
            conditionals: []const Conditional = &.{},
        };

        const StorageType = struct {
            declaration: enum { int, ImU8 },
        };
    };

    const Struct = struct {
        name: []const u8,
        is_anonymous: bool,
        kind: enum { @"struct", @"union" },
        forward_declaration: bool,
        fields: []const Field,
        conditionals: []const Conditional = &.{},

        const Field = struct {
            name: []const u8,
            is_anonymous: bool,
            type: Type,
            width: ?usize = null,
            default_value: ?std.json.Value = null,
            conditionals: []const Conditional = &.{},
        };
    };

    const Function = struct {
        original_class: ?[]const u8 = null,
        name: []const u8,
        arguments: []const Argument = &.{},
        return_type: Type,
        conditionals: []const Conditional = &.{},

        const Argument = struct {
            type: ?Type = null,
            is_varargs: bool,
            is_instance_pointer: bool,
            default_value: ?[]const u8 = null,
        };
    };

    // `dear_bindings` doesn't parse these for us, it just forwards the c preprocessor strings.
    // This is a whitelist of the current values so that we can react appropriately as new values
    // are added.
    const Conditional = struct {
        condition: enum { ifdef, ifndef, @"if", ifnot },
        expression: []const u8,
    };

    const Type = struct {
        type_details: ?Details = null,
        description: Description,
        declaration: ?[]const u8 = null,

        const Details = struct {
            flavour: enum { function_pointer },
            arguments: []const struct {
                type: Type,
                is_array: bool,
                is_varargs: bool,
            },
            return_type: *Type,
        };

        const Description = struct {
            kind: enum { Type, Function, Array, Pointer, Builtin, User },
            // We explicitly set the enum size to u8 as a workaround for
            // https://github.com/ziglang/zig/issues/23168
            storage_classes: []const enum(u8) { @"const" } = &.{},
            inner_type: ?*Description = null,
            bounds: ?[]const u8 = null, // Literal or variable
            builtin_type: ?Builtin = null,
            name: ?[]const u8 = null,

            const Builtin = enum {
                void,
                char,
                unsigned_char,
                short,
                unsigned_short,
                int,
                unsigned_int,
                long,
                unsigned_long,
                long_long,
                unsigned_long_long,
                float,
                double,
                long_double,
                bool,
            };
        };
    };
};

pub fn main() !void {
    // Allocator and command line args
    var gpa = std.heap.GeneralPurposeAllocator(.{
        .thread_safe = false,
    }){};
    defer std.debug.assert(gpa.deinit() == .ok);
    const allocator = gpa.allocator();

    var args = try std.process.argsWithAllocator(allocator);
    defer args.deinit();
    std.debug.assert(args.skip());
    const in_path = args.next().?;
    const out_path = args.next().?;
    const prefix_path = args.next();
    const postfix_path = args.next();
    std.debug.assert(args.next() == null);

    const out = try std.fs.cwd().createFile(out_path, .{});
    defer out.close();
    var writer_buf: [4096]u8 = undefined;
    var file_writer = out.writerStreaming(&writer_buf);
    const writer = &file_writer.interface;

    // Write the prefix
    if (prefix_path) |p| {
        const prefix_source = try std.fs.cwd().readFileAlloc(allocator, p, max_size);
        defer allocator.free(prefix_source);
        try writer.writeAll(prefix_source);
        try writer.writeAll("\n// End of prefix\n\n");
    }

    // Write the source
    {
        const source = try std.fs.cwd().readFileAlloc(allocator, in_path, max_size);
        defer allocator.free(source);

        const header = try std.json.parseFromSlice(Header, allocator, source, .{
            .ignore_unknown_fields = true,
        });
        defer header.deinit();

        // We need the list of declarations up front.
        var declarations = try getDeclarations(allocator, &header.value);
        defer declarations.deinit();

        // Write all defines as private constants.
        try writeDefines(writer, &header.value);

        // Write all typedefs as private constants.
        try writeTypedefs(writer, &header.value, &declarations);

        // Write all cimgui functions as private extern functions.
        try writeExternFunctions(writer, &header.value, &declarations);

        // Alias cimgui free functions under Zig friendly names.
        try writeFreeFunctions(writer, &header.value);

        // Get a list of cimgui methods. These were already written as externs, and can be aliased
        // when we write their respective types.
        var methods = try Methods.get(allocator, &header.value);
        defer methods.deinit(allocator);

        // Write cimgui enums as Zig enums.
        try writeEnums(allocator, writer, &header.value);

        // Write cimgui structs as Zig structs and unions.
        try writeStructs(writer, &header.value, &declarations, &methods);

        // Write helpers used by the other generated code.
        try writeHelpers(writer);
    }

    // Write the postfix
    if (postfix_path) |p| {
        const postfix_source = try std.fs.cwd().readFileAlloc(allocator, p, max_size);
        defer allocator.free(postfix_source);
        try writer.writeAll("\n// Start of postfix\n\n");
        try writer.writeAll(postfix_source);
    }

    // Flush and exit
    try writer.flush();
}

fn getDeclarations(allocator: Allocator, header: *const Header) !Declarations {
    var declarations = Declarations.init(allocator);
    errdefer declarations.deinit();
    for (header.structs) |ty| {
        if (skip(ty.conditionals)) continue;

        var kind: DeclarationKind = .normal;
        if (ty.forward_declaration) {
            if (std.mem.eql(u8, "ImDrawData", ty.name)) {
                // Normally if a type has the forward declaration flag set, we want to mark it as
                // opaque. In the case of draw data, however, the ImGui backends opt to forward
                // declare it instead of include it. If we were to mark it as opaque here, it would
                // be opaque in the backends but an actual type in imgui.
                //
                // Instead, Zig ports of the backends should import DrawData.
                kind = .import;
            } else {
                kind = .@"opaque";
            }
        } else if (ty.kind == .@"struct") {
            for (ty.fields) |field| if (field.width != null) {
                // Treat packed structs as opaque.
                //
                // We *could* write out the Zig code to pack them by passing the widths in when
                // writing the type (and overwriting number types with the actual width, asserting
                // otherwise.)
                //
                // However, we'd need to decide the correct backing type for the packed struct to
                // make it compatible with C. I'm also not 100% what the guarantees are for packed
                // struct layout in C.
                kind = .@"opaque";
                break;
            };
        }

        const trimmed = std.mem.trimRight(u8, ty.name, "_");
        try declarations.put(trimmed, kind);
    }

    for (header.enums) |e| {
        if (e.is_internal) continue;
        if (skip(e.conditionals)) continue;

        const trimmed = std.mem.trimRight(u8, e.name, "_");
        try declarations.put(trimmed, .normal);
    }

    return declarations;
}

fn writeDefines(writer: anytype, header: *const Header) !void {
    for (header.defines) |define| {
        if (define.is_internal) continue;
        if (skip(define.conditionals)) continue;
        if (define.content) |content| {
            if (std.mem.startsWith(u8, content, "(")) {
                const end = std.mem.indexOfScalar(u8, content, ')').?;
                const ty = content[1..end];
                const val = content[end + 1 ..];
                try writer.print("const {s}: ", .{define.name});
                try writeTypeName(writer, ty);
                try writer.print(" = {s};\n", .{val});
            } else {
                try writer.print("const {s} = {s};\n", .{ define.name, content });
            }
        }
    }
}

fn writeTypedefs(writer: anytype, header: *const Header, declarations: *const Declarations) !void {
    for (header.typedefs) |typedef| {
        // Skip typedefs skipped by the preprocessor
        if (skip(typedef.conditionals)) continue;

        // Skip duplicate declarations (e.g. naming enums as ints in C)
        if (declarations.contains(typedef.name)) continue;

        // Skip redundant typedefs (comes up with `SDL_Event`)
        if (typedef.type.declaration != null and
            std.mem.eql(u8, typedef.name, typedef.type.declaration.?)) continue;

        // Write the typedef prefix
        try writer.writeAll("const ");
        try writeTypeName(writer, typedef.name);
        try writer.writeAll(" = ");
        try writeType(writer, typedef.type, declarations, .{});
        try writer.writeAll(";\n");
    }
}

fn writeExternFunctions(
    writer: anytype,
    header: *const Header,
    declarations: *const Declarations,
) !void {
    for (header.functions) |function| {
        if (skip(function.conditionals)) continue;
        if (argsContainsVaList(function.arguments)) continue;

        try writer.print("extern fn {s}(", .{function.name});
        for (function.arguments) |argument| {
            if (argument.type) |ty| {
                std.debug.assert(!argument.is_varargs);
                try writeType(writer, ty, declarations, .{
                    .is_instance_pointer = argument.is_instance_pointer,
                    .is_argument = true,
                    .default_null = if (argument.default_value) |d| std.mem.eql(u8, d, "NULL") else false,
                });
            } else {
                std.debug.assert(argument.is_varargs);
                try writer.writeAll("...");
            }
            try writer.writeAll(", ");
        }
        try writer.writeAll(") callconv(.c) ");
        try writeType(writer, function.return_type, declarations, .{ .is_result = true });
        try writer.writeAll(";\n");
    }
}

fn argsContainsVaList(arguments: []const Header.Function.Argument) bool {
    for (arguments) |argument| {
        if (argument.type) |ty| {
            if (ty.description.name) |name| {
                if (std.mem.eql(u8, name, "va_list")) return true;
            }
        }
    }
    return false;
}

fn writeFreeFunctions(writer: anytype, header: *const Header) !void {
    for (header.functions) |function| {
        if (skip(function.conditionals)) continue;
        if (function.original_class != null) continue;
        if (argsContainsVaList(function.arguments)) continue;

        try writer.writeAll("pub const ");
        try writeFunctionName(writer, function.name);
        try writer.print(" = {s};\n", .{function.name});
    }
}

const Methods = struct {
    types: std.StringArrayHashMap(std.ArrayList([]const u8)),

    fn get(allocator: Allocator, header: *const Header) !Methods {
        // Initialize an empty method list for each type
        var types = std.StringArrayHashMap(std.ArrayList([]const u8)).init(allocator);
        errdefer types.deinit();
        errdefer for (types.values()) |*methods| {
            methods.deinit(allocator);
        };
        for (header.structs) |ty| {
            var methods: std.ArrayList([]const u8) = .empty;
            errdefer methods.deinit(allocator);
            try types.put(ty.name, methods);
        }

        // Fill in the method lists
        for (header.functions) |function| {
            if (skip(function.conditionals)) continue;
            if (argsContainsVaList(function.arguments)) continue;

            if (function.original_class) |class| {
                const methods = types.getPtr(class).?;
                try methods.append(allocator, function.name);
            }
        }

        return .{ .types = types };
    }

    fn deinit(self: *Methods, allocator: Allocator) void {
        for (self.types.values()) |*methods| {
            methods.deinit(allocator);
        }
        self.types.deinit();
        self.* = undefined;
    }
};

fn writeEnums(allocator: Allocator, writer: anytype, header: *const Header) !void {
    for (header.enums) |e| {
        if (e.is_internal) continue;
        if (skip(e.conditionals)) continue;

        try writer.writeAll("pub const ");
        try writeTypeName(writer, e.name);
        try writer.writeAll(" = ");

        if (e.is_flags_enum) {
            try writeFlagsEnum(writer, e);
        } else {
            try writeNormalEnum(allocator, writer, e);
        }
    }
}

fn writeFlagsEnum(writer: anytype, e: Header.Enum) !void {
    const backing, const backing_bits = switch (e.storage_type.declaration) {
        .int => .{ "c_int", @typeInfo(c_int).int.bits },
        .ImU8 => .{ "u8", 8 },
    };
    try writer.print("packed struct({s}) {{\n", .{backing});
    var current_offset: usize = 0;
    var padding_i: usize = 0;
    for (e.elements) |element| {
        // Skip internal elements, and elements discarded by preprocessor
        if (skip(element.conditionals)) continue;
        if (element.is_internal) continue;
        if (element.value == 0) continue;

        // Calculate the offset of this element
        const offset = std.math.log2(@as(usize, @intCast(element.value)));

        // Sometimes at the end of flag sets, elements are defined that are combinations of
        // existing flags. Skip these--the only reasonable representation would be constants, but
        // they're hard to compose in Zig so it's not worth it.
        if (offset < current_offset) {
            continue;
        }

        // Add padding to get this element to the correct offset
        const padding = offset - current_offset;
        if (padding > 0) {
            try writer.print("    __padding{}: u{} = 0,\n", .{ padding_i, padding });
            padding_i += 1;
            current_offset = offset;
        }

        // Write the element
        try writer.writeAll("    ");
        try writeElementName(writer, e.name, element.name);
        try writer.writeAll(": bool = false,\n");
        current_offset += 1;
    }

    // Add padding at end to make total type the correct size
    const padding = backing_bits - current_offset;
    if (padding > 0) {
        try writer.print("    __padding{}: u{} = 0,\n", .{ padding_i, padding });
    }

    try writer.writeAll("};\n");
}

fn writeNormalEnum(allocator: Allocator, writer: anytype, e: Header.Enum) !void {
    var values = std.AutoArrayHashMap(i64, void).init(allocator);
    defer values.deinit();

    try writer.writeAll("enum(");
    switch (e.storage_type.declaration) {
        .int => try writer.writeAll("c_int"),
        .ImU8 => try writer.writeAll("u8"),
    }
    try writer.writeAll(") {\n");

    // Write elements
    for (e.elements) |element| {
        // Skip internal and count
        if (element.is_internal) continue;
        if (element.is_count) continue;
        if (skip(element.conditionals)) continue;

        // We skip duplicate values, these are sometimes present e.g. in the keys enum which
        // contains the mods enum and therefore two "none" options that are identical.
        if (values.contains(element.value)) continue;
        try values.put(element.value, {});

        // Write the element
        try writer.writeAll("    ");
        try writeElementName(writer, e.name, element.name);
        try writer.print(" = {},\n", .{element.value});
    }

    // Write constants since they're used internally, but keep them private
    for (e.elements) |element| {
        if (element.is_count) {
            try writer.writeAll("    const ");
            try writeElementName(writer, e.name, element.name);
            try writer.print(" = {};\n", .{element.value});
        }
    }

    try writer.writeAll("};\n");
}

fn writeStructs(
    writer: anytype,
    header: *const Header,
    declarations: *const Declarations,
    methods: *const Methods,
) !void {
    for (header.structs) |ty| {
        // Skip structs skipped by the preprocessor. We don't skip structs marked as internal,
        // because many of these appear to be generally useful (it may be set incorrectly in the
        // JSON?)
        if (skip(ty.conditionals)) continue;

        // Skip imported decls
        const decl_kind = declarations.get(ty.name).?;
        if (decl_kind == .import) continue;

        // Write the struct
        try writer.writeAll("pub const ");
        try writeTypeName(writer, ty.name);
        try writer.writeAll(" = ");

        // If we're opaque, don't try to fill out the struct fields
        if (decl_kind == .@"opaque") {
            try writer.writeAll("opaque {};\n");
            continue;
        }

        // Declare the struct or union
        switch (ty.kind) {
            .@"struct" => try writer.writeAll("extern struct {\n"),
            .@"union" => try writer.writeAll("extern union {\n"),
        }

        // Fill in the fields
        for (ty.fields) |field| {
            // Skip fields skipped by the preprocessor.
            if (skip(field.conditionals)) continue;

            // Not yet used, but when it is we want to start using it. Safe to disable this assert
            // if you're just trying to get things working with a different version.
            if (field.default_value != null) @panic("unimplemented");

            // Write the field.
            try writer.writeAll("    ");
            if (field.is_anonymous) {
                try writer.writeAll("data");
            } else {
                try writeFieldName(writer, field.name);
            }
            try writer.writeAll(": ");
            try writeType(writer, field.type, declarations, .{});
            try writer.writeAll(",\n");
        }

        // Alias all relevant methods into the type.
        const method_names = methods.types.getPtr(ty.name).?;
        for (method_names.items) |name| {
            try writer.writeAll("    pub const ");
            try writeFunctionName(writer, name[ty.name.len + 1 ..]);
            try writer.print(" = {s};\n", .{name});
        }

        try writer.writeAll("};\n");
    }
}

fn writeHelpers(writer: anytype) !void {
    try writer.writeAll(
        \\fn toUsize(v: anytype) usize {
        \\    if (@typeInfo(@TypeOf(v)) == .@"enum") return @intFromEnum(v);
        \\    return @intCast(v);
        \\}
        \\
    );
}

// Type hints aren't required, but they help us figure out the best pointer types to use.
const WriteTypeHints = packed struct {
    is_instance_pointer: bool = false,
    is_argument: bool = false,
    default_null: bool = false,
    is_result: bool = false,
};

// Write a cimgui type as a Zig type.
fn writeType(
    writer: anytype,
    ty: Header.Type,
    declarations: *const Declarations,
    hints: WriteTypeHints,
) std.Io.Writer.Error!void {
    // Handle function pointers which are stored separately.
    if (ty.type_details) |details| switch (details.flavour) {
        .function_pointer => return writeFunctionPointer(writer, details, declarations),
    };

    // Handle all other types
    switch (ty.description.kind) {
        .Builtin => return writeBuiltinType(writer, ty.description.builtin_type.?),
        .Array => return writeArrayType(writer, ty.description, declarations),
        .Pointer => return writePointerType(writer, ty, declarations, hints),
        .User => try writeTypeName(writer, ty.description.name.?),
        .Type, .Function => @panic("unimplemented"),
    }
}

fn writeFunctionPointer(
    writer: anytype,
    details: Header.Type.Details,
    declarations: *const Declarations,
) !void {
    try writer.writeAll("*const fn(");
    for (details.arguments) |argument| {
        try writeType(writer, argument.type, declarations, .{});
        try writer.writeAll(", ");
    }
    try writer.writeAll(") callconv(.c) ");
    try writeType(writer, details.return_type.*, declarations, .{});
}

fn writeBuiltinType(writer: anytype, builtin_type: Header.Type.Description.Builtin) !void {
    switch (builtin_type) {
        .void => try writer.writeAll("void"),
        .char, .unsigned_char => try writer.writeAll("u8"),
        .short => try writer.writeAll("c_short"),
        .unsigned_short => try writer.writeAll("c_ushort"),
        .int => try writer.writeAll("c_int"),
        .unsigned_int => try writer.writeAll("c_uint"),
        .long => try writer.writeAll("c_long"),
        .unsigned_long => try writer.writeAll("c_ulong"),
        .long_long => try writer.writeAll("c_longlong"),
        .unsigned_long_long => try writer.writeAll("c_ulonglong"),
        .float => try writer.writeAll("f32"),
        .double => try writer.writeAll("f64"),
        .long_double => try writer.writeAll("c_longdouble"),
        .bool => try writer.writeAll("bool"),
    }
}

fn writeArrayType(
    writer: anytype,
    description: Header.Type.Description,
    declarations: *const Declarations,
) !void {
    if (description.bounds) |bounds| {
        try writeArrayBounds(writer, bounds);
    } else {
        try writer.writeAll("[*]");
    }
    try writeType(
        writer,
        .{ .description = description.inner_type.?.* },
        declarations,
        .{},
    );
}

// Array bounds sometimes include expressions, so we need to tokenize them and convert the
// expressions to Zig syntax.
fn writeArrayBounds(writer: anytype, bounds: []const u8) !void {
    try writer.writeByte('[');
    var token_start: usize = 0;
    while (token_start < bounds.len) {
        // Calculate token start
        if (bounds[token_start] == ' ') {
            token_start += 1;
            continue;
        }

        // Special handling for one character tokens
        switch (bounds[token_start]) {
            '(' => {
                const token = bounds[token_start .. token_start + 1];
                token_start += 1;
                try writer.writeAll(token);
                continue;
            },
            '+', '/' => {
                const token = bounds[token_start .. token_start + 1];
                token_start += 1;
                try writer.print(" {s} ", .{token});
                continue;
            },
            else => {},
        }

        // Calculate token end
        var token_end = token_start + 1;
        while (token_end < bounds.len) : (token_end += 1) {
            switch (bounds[token_end]) {
                ' ', '+', ')', '/' => break,
                else => {},
            }
        }
        const token = bounds[token_start..token_end];
        token_start = token_end;

        // As of the time of writing, tokens here are either numbers or enum values.
        if (std.mem.indexOfScalar(u8, token, '_')) |underscore| {
            // If it's all uppercase, it's a define. Otherwise it's an enum.
            const is_define = for (token) |c| {
                switch (c) {
                    'a'...'z' => break false,
                    else => {},
                }
            } else true;

            if (is_define) {
                try writer.writeAll(token);
            } else {
                try writer.writeAll("toUsize(");
                const type_name = token[0..underscore];
                try writeTypeName(writer, type_name);
                try writer.writeByte('.');
                try writeElementName(writer, type_name, token);
                try writer.writeAll(")");
            }
        } else {
            // Otherwise, just write the value as is.
            try writer.writeAll(token);
        }
    }
    try writer.writeByte(']');
}

fn writePointerType(
    writer: anytype,
    ty: Header.Type,
    declarations: *const Declarations,
    hints: WriteTypeHints,
) !void {
    // Check if we're a pointer to an opaque type
    var is_opaque = false;
    if (ty.description.inner_type.?.name) |name| {
        if (declarations.get(name)) |kind| {
            is_opaque = kind == .@"opaque";
        }
    }

    // Check if we're a pointer to void
    const is_void = ty.description.inner_type.?.builtin_type == .void;

    // Check if we're a string
    const is_string = b: {
        if (ty.description.inner_type.?.builtin_type != .char) break :b false;
        for (ty.description.inner_type.?.*.storage_classes) |storage_class| switch (storage_class) {
            .@"const" => break :b true,
        };
        break :b false;
    };

    // Use the hints to decide what kind of pointer we are
    if (is_string) {
        // We currently write all strings as c pointers since some are null terminated, and some are
        // not.
        try writer.writeAll("[*c]");
    } else if (hints.is_instance_pointer) {
        // We assume all instance pointers do *not* allow null.
        std.debug.assert(!hints.default_null);
        try writer.writeByte('*');
    } else if (hints.is_argument) {
        // Arguments are assumed to be single value pointers, because many value pointers when
        // passed as arguments get marked as arrays and handled separately from pointers.
        if (hints.default_null) {
            // If the default value is set to null, we must be nullable. Otherwise we conservatively
            // assume null is not allowed, which tends to be correct in practice more often than
            // not.
            try writer.writeByte('?');
        }
        try writer.writeByte('*');
    } else if (hints.is_result) {
        // Results are assumed to be single value pointers, since otherwise, we'd have no way of
        // knowing the length. We conservatively assume these are nullable since we have no way of
        // knowing. Ideally dear bindings would mark this eventually (there is a field for it but
        // it is unused), if it becomes annoying we can always add a whitelist.
        try writer.writeAll("?*");
    } else {
        // If we've reached this case, we're a struct field, and we don't know whether it's many
        // value or nullable. We fall back to a c pointer so that the user can decide how to
        // interpret it with less friction, unless it's an opaque type in which case that's not
        // allowed so we assume it's a nullable single value pointer.
        if (is_opaque or is_void) {
            try writer.writeAll("?*");
        } else {
            try writer.writeAll("[*c]");
        }
    }

    // Write any storage classes
    for (ty.description.inner_type.?.*.storage_classes) |storage_class| switch (storage_class) {
        .@"const" => try writer.writeAll("const "),
    };

    // Write the actual type
    if (is_void) {
        // Treat pointers to c void as pointers to anyopaque
        try writer.writeAll("anyopaque");
    } else {
        try writeType(
            writer,
            .{ .description = ty.description.inner_type.?.* },
            declarations,
            .{},
        );
    }
}

// Returns true if we should skip due to a conditional
fn skip(conditionals: []const Header.Conditional) bool {
    for (conditionals) |conditional| {
        // We just manually decide which of these are correct rather than trying to automatically
        // parse them. We do this with a chain of if statements because std.json doesn't give us any
        // information about what string it saw or what line number the error was on if we try to
        // parse it as an enum, which is a huge pain when upgrading dear imgui.
        const defined = b: {
            // True conditionals
            if (std.mem.eql(u8, conditional.expression, "IMGUI_DISABLE_OBSOLETE_FUNCTIONS")) break :b true;
            if (std.mem.eql(u8, conditional.expression, "IMGUI_DISABLE_OBSOLETE_FUNCTIONS")) break :b true;
            if (std.mem.eql(u8, conditional.expression, "IMGUI_DISABLE_OBSOLETE_KEYIO")) break :b true;
            if (std.mem.eql(u8, conditional.expression, "CIMGUI_API")) break :b true;
            if (std.mem.eql(u8, conditional.expression, "CIMGUI_IMPL_API")) break :b true;
            if (std.mem.eql(u8, conditional.expression, "defined(IMGUI_IMPL_VULKAN_NO_PROTOTYPES)&&!defined(VK_NO_PROTOTYPES)")) break :b true;
            if (std.mem.eql(u8, conditional.expression, "defined(VK_USE_PLATFORM_WIN32_KHR)&&!defined(NOMINMAX)")) break :b true;
            if (std.mem.eql(u8, conditional.expression, "IMGUI_IMPL_VULKAN_HAS_DYNAMIC_RENDERING")) break :b true;
            if (std.mem.eql(u8, conditional.expression, "defined(VK_VERSION_1_3)|| defined(VK_KHR_dynamic_rendering)")) break :b true;

            // False conditionals
            if (std.mem.eql(u8, conditional.expression, "IMGUI_OVERRIDE_DRAWVERT_STRUCT_LAYOUT")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "IMGUI_USE_WCHAR32")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "ImTextureID")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "ImDrawIdx")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "ImDrawCallback")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "defined(_MSC_VER)&&!defined(__clang__)&&!defined(__INTEL_COMPILER)&&!defined(IMGUI_DEBUG_PARANOID)")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "defined(IMGUI_DISABLE_OBSOLETE_FUNCTIONS)&&!defined(IMGUI_DISABLE_OBSOLETE_KEYIO)")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "IMGUI_DEFINE_MATH_OPERATORS")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "IM_COL32_R_SHIFT")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "IMGUI_USE_BGRA_PACKED_COLOR")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "IM_DRAWLIST_TEX_LINES_WIDTH_MAX")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "defined(IMGUI_DISABLE_METRICS_WINDOW)&&!defined(IMGUI_DISABLE_OBSOLETE_FUNCTIONS)&&!defined(IMGUI_DISABLE_DEBUG_TOOLS)")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "defined(IMGUI_HAS_IMSTR)")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "IMGUI_HAS_IMSTR")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "IMGUI_DISABLE_DEBUG_TOOLS")) break :b false;
            if (std.mem.eql(u8, conditional.expression, "ImTextureID_Invalid")) break :b false;

            std.debug.panic("unexpected preprocessor conditional: {s}", .{conditional.expression});
        };
        switch (conditional.condition) {
            .ifdef, .@"if" => if (!defined) return true,
            .ifndef, .ifnot => if (defined) return true,
        }
    }
    return false;
}

// Converts a cimgui type name to a Zig type name
fn writeTypeName(writer: anytype, raw: []const u8) !void {
    // These are considered user types
    if (std.mem.eql(u8, raw, "size_t")) {
        try writer.writeAll("usize");
        return;
    }

    if (std.mem.eql(u8, raw, "uint32_t")) {
        try writer.writeAll("u32");
        return;
    }

    // We skip all declarations that contain `va_list`, so this shouldn't trigger.
    if (std.mem.eql(u8, raw, "va_list")) unreachable;

    // Remove prefixes
    var name = raw;
    {
        // Imgui prefixes
        {
            const prefixes: []const []const u8 = &.{ "ImGui", "Im" };
            for (prefixes) |prefix| {
                if (std.mem.startsWith(u8, name, prefix)) {
                    name = name[prefix.len..];
                    break;
                }
            }
        }

        // Backend prefixes
        {
            const prefixes: []const []const u8 = &.{ "_ImplVulkanH", "_ImplVulkan", "_ImplSDL3" };
            for (prefixes) |prefix| {
                if (std.mem.startsWith(u8, name, prefix)) {
                    name = name[prefix.len..];
                    break;
                }
            }
        }
    }

    const escaped = std.mem.indexOfScalar(u8, name, '<') != null;

    if (escaped) try writer.writeAll("@\"");

    for (name) |c| switch (c) {
        '_' => {},
        else => try writer.writeByte(c),
    };

    if (escaped) try writer.writeByte('"');
}

// Convert a cimgui field name to a Zig field name
fn writeFieldName(writer: anytype, name: []const u8) !void {
    var escape = false;
    for (name, 0..) |c, i| {
        switch (c) {
            '0'...'9' => {
                if (i == 0) {
                    escape = true;
                    try writer.writeAll("@\"");
                }
                try writer.writeByte(c);
            },
            'a'...'z' => try writer.writeByte(c),
            'A'...'Z' => {
                if (i > 0 and i < name.len - 1) switch (name[i + 1]) {
                    'A'...'Z', '_' => {},
                    else => try writer.writeByte('_'),
                };
                try writer.writeByte(c + 32);
            },
            '_' => if (i != name.len - 1) try writer.writeByte('_'),
            else => std.debug.panic("unexpected char in name: {c}", .{c}),
        }
    }
    if (escape) try writer.writeAll("\"");
}

// Convert a cimgui element name to a Zig element name
fn writeElementName(writer: anytype, type_name: []const u8, raw: []const u8) !void {
    var name = if (std.mem.startsWith(u8, raw, type_name)) raw[type_name.len..] else raw;
    name = if (std.mem.startsWith(u8, name, "ImGui")) name["ImGui".len..] else name;
    name = if (name[0] == '_') name[1..] else name;
    try writeFieldName(writer, name);
}

// Write a cimgui function name as a Zig function name
fn writeFunctionName(writer: anytype, raw: []const u8) !void {
    var name = raw;

    // Imgui prefixes
    {
        const prefixes: []const []const u8 = &.{ "cImGui_ImplVulkan", "cImGui_ImplSDL3", "ImGui", "Im" };
        for (prefixes) |prefix| {
            if (std.mem.startsWith(u8, name, prefix)) {
                name = name[prefix.len..];
                break;
            }
        }
    }

    if (name[0] == '_') name = name[1..];

    // Lowercase the first set of contiguous capital letters
    var i: usize = 0;
    while (i < name.len and name[i] >= 'A' and name[i] <= 'Z') : (i += 1) {
        try writer.writeByte(name[i] + 32);
    }

    // The rest of the string is usually already camelcase, write it as is unless we encounter an
    // underscore in which case we should skip it an uppercase the next letter.
    if (i < name.len) {
        var uppercase_next = false;
        for (name[i..]) |c| {
            // If we're an underscore, skip it and uppercase the next letter
            if (c == '_') {
                uppercase_next = true;
                continue;
            }

            // Write the next character, adjusting the case as necessary
            switch (c) {
                'a'...'z' => try writer.writeByte(if (uppercase_next) c - 32 else c),
                else => try writer.writeByte(c),
            }
            uppercase_next = false;
        }
    }
}