const std = @import("std");

const EnumFlags = @import("EnumFlags.zig").EnumFlags;

allocator: std.mem.Allocator,

magic: u32,
minor_version: u16,
major_version: u16,
constant_pool: []?CpInfo,
access_flags: ClassAccessFlags,
this_class: u16,
super_class: u16,
interfaces: []u16,
fields: []FieldInfo,
methods: []MethodInfo,
attributes: []AttributeInfo,

const Self = @This();

const ParseError = std.Io.Reader.Error || std.mem.Allocator.Error || error {
    InvalidMagicNumber,
    InvalidTag,
};

const ResolveError = error {
    InvalidConstantPoolIndex,
    InvalidConstantType,
};

pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError!Self {
    const magic = try input.takeInt(u32, .big);
    if (magic != 0xCAFEBABE) {
        return ParseError.InvalidMagicNumber;
    }

    const minor_version = try input.takeInt(u16, .big);
    const major_version = try input.takeInt(u16, .big);

    const constant_pool = try parseConstantPool(input, allocator);
    errdefer {
        for (constant_pool) |*cp_info| {
            if (cp_info.*) |*c| c.deinit(allocator);
        }
        allocator.free(constant_pool);
    }

    const access_flags: ClassAccessFlags = .{ .mask = try input.takeInt(u16, .big) };

    const this_class = try input.takeInt(u16, .big);
    const super_class = try input.takeInt(u16, .big);

    const interfaces = try parseInterfaces(input, allocator);
    errdefer allocator.free(interfaces);

    const fields = try parseFields(input, allocator);
    errdefer {
        for (fields) |*field| {
            field.deinit(allocator);
        }
        allocator.free(fields);
    }

    const methods = try parseMethods(input, allocator);
    errdefer {
        for (methods) |*method| {
            method.deinit(allocator);
        }
        allocator.free(methods);
    }

    const attributes = try parseAttributes(input, allocator);
    errdefer {
        for (attributes) |*attribute| {
            attribute.deinit(allocator);
        }
        allocator.free(attributes);
    }

    return .{
        .allocator = allocator,
        .magic = magic,
        .minor_version = minor_version,
        .major_version = major_version,
        .constant_pool = constant_pool,
        .access_flags = access_flags,
        .this_class = this_class,
        .super_class = super_class,
        .interfaces = interfaces,
        .fields = fields,
        .methods = methods,
        .attributes = attributes,
    };
}

fn parseConstantPool(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError![]?CpInfo {
    const constant_pool_size = try input.takeInt(u16, .big);
    const constant_pool = try allocator.alloc(?CpInfo, constant_pool_size - 1);
    errdefer allocator.free(constant_pool);

    var i: usize = 0;
    while (i < constant_pool_size - 1) {
        defer i += 1;

        const cp_info = try CpInfo.parse(input, allocator);
        constant_pool[i] = cp_info;

        switch (cp_info) {
            .long, .double => {
                i += 1;
                constant_pool[i] = null;
            },
            else => {},
        }
    }

    return constant_pool;
}

fn parseInterfaces(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError![]u16 {
    const interfaces_count = try input.takeInt(u16, .big);
    const interfaces = try allocator.alloc(u16, interfaces_count);
    errdefer allocator.free(interfaces);

    for (0..interfaces_count) |i| {
        interfaces[i] = try input.takeInt(u16, .big);
    }

    return interfaces;
}

fn parseFields(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError![]FieldInfo {
    const fields_count = try input.takeInt(u16, .big);
    const fields = try allocator.alloc(FieldInfo, fields_count);
    errdefer allocator.free(fields);

    for (0..fields_count) |i| {
        fields[i] = try FieldInfo.parse(input, allocator);
    }

    return fields;
}

fn parseMethods(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError![]MethodInfo {
    const methods_count = try input.takeInt(u16, .big);
    const methods = try allocator.alloc(MethodInfo, methods_count);
    errdefer allocator.free(methods);

    for (0..methods_count) |i| {
        methods[i] = try MethodInfo.parse(input, allocator);
    }

    return methods;
}

fn parseAttributes(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError![]AttributeInfo {
    const attributes_count = try input.takeInt(u16, .big);
    const attributes = try allocator.alloc(AttributeInfo, attributes_count);
    errdefer allocator.free(attributes);

    for (0..attributes_count) |i| {
        attributes[i] = try AttributeInfo.parse(input, allocator);
    }

    return attributes;
}

pub fn deinit(self: *Self) void {
    self.freeConstantPool();
    self.freeInterfaces();
    self.freeFields();
    self.freeMethods();
    self.freeAttributes();
}

fn freeConstantPool(self: *Self) void {
    for (self.constant_pool) |*cp_info| {
        if (cp_info.*) |*c| c.deinit(self.allocator);
    }
    self.allocator.free(self.constant_pool);
}

fn freeInterfaces(self: *Self) void {
    self.allocator.free(self.interfaces);
}

fn freeFields(self: *Self) void {
    for (self.fields) |*field_info| {
        field_info.deinit(self.allocator);
    }
    self.allocator.free(self.fields);
}

fn freeMethods(self: *Self) void {
    for (self.methods) |*method_info| {
        method_info.deinit(self.allocator);
    }
    self.allocator.free(self.methods);
}

fn freeAttributes(self: *Self) void {
    for (self.attributes) |*attr| {
        attr.deinit(self.allocator);
    }
    self.allocator.free(self.attributes);
}

pub fn jsonStringify(self: *const Self, jws: *std.json.Stringify) !void {
    try jws.beginObject();

    inline for (std.meta.fields(Self)) |field| {
        if (comptime std.mem.eql(u8, field.name, "allocator")) continue;
        try jws.objectField(field.name);
        try jws.write(@field(self, field.name));
    }

    try jws.endObject();
}

pub fn format(self: *const Self, w: *std.Io.Writer) std.Io.Writer.Error!void {
    const depth = 2;
    var indent: u8 = 0;

    try w.print("magic: 0x{X}\n", .{ self.magic });

    try w.print("version: {d}.{d}\n", .{ self.major_version, self.minor_version });

    try w.print("flags: {f}\n", .{ self.access_flags });

    const this_class = self.thisClass() catch return error.WriteFailed;
    _ = try w.write("this class:\n");
    try this_class.format(w, depth, indent + 1, self.constant_pool);

    if (self.superClass() catch return error.WriteFailed) |super_class| {
        _ = try w.write("super class:\n");
        try super_class.format(w, depth, indent + 1, self.constant_pool);
    }

    _ = try w.write("interfaces:\n");
    for (self.interfaces, 0..) |interface, i| {
        indent += 1;
        defer indent -= 1;

        if (interface >= self.constant_pool.len) return error.WriteFailed;
        const cp_info = self.constant_pool[interface - 1];
        if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .class) return error.WriteFailed;

        try w.splatByteAll(' ', depth * indent);
        try w.print("{d}:\n", .{ i });
        try cp_info.?.format(w, depth, indent + 1, self.constant_pool);
    }

    _ = try w.write("fields:\n");
    for (self.fields, 0..) |field, i| {
        indent += 1;
        defer indent -= 1;

        try w.splatByteAll(' ', depth * indent);
        try w.print("{d}:\n", .{ i });
        try field.format(w, depth, indent + 1, self.allocator, self.constant_pool);
    }

    _ = try w.write("methods:\n");
    for (self.methods, 0..) |method, i| {
        indent += 1;
        defer indent -= 1;

        try w.splatByteAll(' ', depth * indent);
        try w.print("{d}:\n", .{ i });
        try method.format(w, depth, indent + 1, self.allocator, self.constant_pool);
    }

    _ = try w.write("attributes:\n");
    for (self.attributes, 0..) |*attribute, i| {
        indent += 1;
        defer indent -= 1;

        try w.splatByteAll(' ', depth * indent);
        try w.print("{d}:\n", .{ i });
        try attribute.format(w, depth, indent + 1, self.allocator, self.constant_pool);
    }
}

pub fn thisClass(self: *const Self) ResolveError!CpInfo {
    const this_class = self.this_class - 1;
    if (this_class >= self.constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
    const cp_info = self.constant_pool[this_class];
    if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
    return cp_info.?;
}

pub fn superClass(self: *const Self) ResolveError!?CpInfo {
    // TODO: Determine whether this is an interface or a regular class.
    //       When this is an interface, assert that the super class must be Object.

    if (self.super_class == 0) {
        const this_class = (try self.thisClass()).class;
        const this_class_name = (try this_class.name(self.constant_pool)).utf8;
        if (!std.mem.eql(u8, this_class_name.bytes, "Object")) return ResolveError.InvalidConstantType;
        return null;
    } else {
        const super_class = self.super_class - 1;
        if (super_class >= self.constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
        const cp_info = self.constant_pool[super_class];
        if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
        // TODO: Assert that superclass does not have ACC_FINAL flag set.
        return cp_info.?;
    }
}

pub const CpInfo = union(CpInfo.Tag) {
    class: Class,
    field_ref: FieldRef,
    method_ref: MethodRef,
    interface_method_ref: InterfaceMethodRef,
    string: String,
    integer: Integer,
    float: Float,
    long: Long,
    double: Double,
    name_and_type: NameAndType,
    utf8: Utf8,
    method_handle: MethodHandle,
    method_type: MethodType,
    invoke_dynamic: InvokeDynamic,

    pub const Tag = enum(u8) {
        class = 7,
        field_ref = 9,
        method_ref = 10,
        interface_method_ref = 11,
        string = 8,
        integer = 3,
        float = 4,
        long = 5,
        double = 6,
        name_and_type = 12,
        utf8 = 1,
        method_handle = 15,
        method_type = 16,
        invoke_dynamic = 18,
    };

    pub const Class = struct {
        name_index: u16,

        pub fn name(self: *const Class, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const name_index = self.name_index - 1;
            if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[name_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }
    };

    pub const FieldRef = struct {
        class_index: u16,
        name_and_type_index: u16,

        pub fn class(self: *const FieldRef, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const class_index = self.class_index - 1;
            if (class_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[class_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }

        pub fn nameAndType(self: *const FieldRef, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const name_and_type_index = self.name_and_type_index - 1;
            if (name_and_type_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[name_and_type_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }
    };

    pub const MethodRef = struct {
        class_index: u16,
        name_and_type_index: u16,

        pub fn class(self: *const MethodRef, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const class_index = self.class_index - 1;
            if (class_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[class_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }

        pub fn nameAndType(self: *const MethodRef, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const name_and_type_index = self.name_and_type_index - 1;
            if (name_and_type_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[name_and_type_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }
    };

    pub const InterfaceMethodRef = struct {
        class_index: u16,
        name_and_type_index: u16,

        pub fn class(self: *const InterfaceMethodRef, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const class_index = self.class_index - 1;
            if (class_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[class_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }

        pub fn nameAndType(self: *const InterfaceMethodRef, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const name_and_type_index = self.name_and_type_index - 1;
            if (name_and_type_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[name_and_type_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }
    };

    pub const String = struct {
        string_index: u16,

        pub fn string(self: *const String, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const string_index = self.string_index - 1;
            if (string_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[string_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }
    };

    pub const Integer = struct {
        bytes: u32,
    };

    pub const Float = struct {
        bytes: u32,
    };

    pub const Long = struct {
        high_bytes: u32,
        low_bytes: u32,
    };

    pub const Double = struct {
        high_bytes: u32,
        low_bytes: u32,
    };

    pub const NameAndType = struct {
        name_index: u16,
        descriptor_index: u16,

        pub fn name(self: *const NameAndType, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const name_index = self.name_index - 1;
            if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[name_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }

        pub fn descriptor(self: *const NameAndType, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const descriptor_index = self.descriptor_index - 1;
            if (descriptor_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[descriptor_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }
    };

    pub const Utf8 = struct {
        bytes: []const u8,
    };

    pub const MethodHandle = struct {
        reference_kind: Kind,
        reference_index: u16,

        pub const Kind = enum(u8) {
            get_field = 1,
            get_static = 2,
            put_field = 3,
            put_static = 4,
            invoke_virtual = 5,
            invoke_static = 6,
            invoke_special = 7,
            new_invoke_special = 8,
            invoke_interface = 9,
        };

        pub fn reference(self: *const MethodHandle, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const reference_index = self.reference_index - 1;
            if (reference_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[reference_index];
            return switch (self.reference_kind) {
                .get_field, .get_static, .put_field, .put_static => blk: {
                    if (cp_info == null or @as(Tag, cp_info.?) != .field_ref) break :blk ResolveError.InvalidConstantType;
                    break :blk cp_info.?;
                },
                .invoke_virtual, .invoke_static, .invoke_special, .new_invoke_special => blk: {
                    if (cp_info == null or @as(Tag, cp_info.?) != .method_ref) break :blk ResolveError.InvalidConstantType;
                    break :blk cp_info.?;
                },
                .invoke_interface => blk: {
                    if (cp_info == null or @as(Tag, cp_info.?) != .interface_method_ref) break :blk ResolveError.InvalidConstantType;
                    break :blk cp_info.?;
                },
            };
        }
    };

    pub const MethodType = struct {
        descriptor_index: u16,

        pub fn descriptor(self: *const MethodType, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const descriptor_index = self.descriptor_index - 1;
            if (descriptor_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[descriptor_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }
    };

    pub const InvokeDynamic = struct {
        bootstrap_method_attr_index: u16,
        name_and_type_index: u16,

        pub fn nameAndType(self: *const InvokeDynamic, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
            const name_and_type_index = self.name_and_type_index - 1;
            if (name_and_type_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
            const cp_info = constant_pool[name_and_type_index];
            if (cp_info == null or @as(Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
            return cp_info.?;
        }
    };

    pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError!CpInfo {
        const tag_byte = try input.takeByte();
        const tag = std.enums.fromInt(Tag, tag_byte) orelse return ParseError.InvalidTag;

        return switch (tag) {
            .class => .{
                .class = .{
                    .name_index = try input.takeInt(u16, .big),
                },
            },
            .field_ref => .{
                .field_ref = .{
                    .class_index = try input.takeInt(u16, .big),
                    .name_and_type_index = try input.takeInt(u16, .big),
                },
            },
            .method_ref => .{
                .method_ref = .{
                    .class_index = try input.takeInt(u16, .big),
                    .name_and_type_index = try input.takeInt(u16, .big),
                },
            },
            .interface_method_ref => .{
                .interface_method_ref = .{
                    .class_index = try input.takeInt(u16, .big),
                    .name_and_type_index = try input.takeInt(u16, .big),
                },
            },
            .string => .{
                .string = .{
                    .string_index = try input.takeInt(u16, .big),
                },
            },
            .integer => .{
                .integer = .{
                    .bytes = try input.takeInt(u32, .big),
                },
            },
            .float => .{
                .integer = .{
                    .bytes = try input.takeInt(u32, .big),
                },
            },
            .long => .{
                .long = .{
                    .high_bytes = try input.takeInt(u32, .big),
                    .low_bytes = try input.takeInt(u32, .big),
                },
            },
            .double => .{
                .double = .{
                    .high_bytes = try input.takeInt(u32, .big),
                    .low_bytes = try input.takeInt(u32, .big),
                },
            },
            .name_and_type => .{
                .name_and_type = .{
                    .name_index = try input.takeInt(u16, .big),
                    .descriptor_index = try input.takeInt(u16, .big),
                },
            },
            .utf8 => blk: {
                const length = try input.takeInt(u16, .big);
                const bytes = try input.readAlloc(allocator, length);

                break :blk .{
                    .utf8 = .{
                        .bytes = bytes,
                    },
                };
            },
            .method_handle => blk: {
                const kind_byte = try input.takeByte();
                const kind = std.enums.fromInt(MethodHandle.Kind, kind_byte) orelse return ParseError.InvalidTag;

                break :blk .{
                    .method_handle = .{
                        .reference_kind = kind,
                        .reference_index = try input.takeInt(u16, .big),
                    },
                };
            },
            .method_type => .{
                .method_type = .{
                    .descriptor_index = try input.takeInt(u16, .big),
                },
            },
            .invoke_dynamic => .{
                .invoke_dynamic = .{
                    .bootstrap_method_attr_index = try input.takeInt(u16, .big),
                    .name_and_type_index = try input.takeInt(u16, .big),
                },
            },
        };
    }

    pub fn deinit(self: *CpInfo, allocator: std.mem.Allocator) void {
        switch (self.*) {
            .utf8 => |info| allocator.free(info.bytes),
            else => {},
        }
    }

    pub fn format(self: *const CpInfo, w: *std.Io.Writer, depth: usize, indent: u8, constant_pool: []const ?CpInfo) std.Io.Writer.Error!void {
        try w.splatByteAll(' ', depth * indent);
        try w.print("constant_value_type: {s}\n", .{ @tagName(self.*) });

        switch (self.*) {
            .class => |class| {
                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("name:\n");
                const class_name = class.name(constant_pool) catch return error.WriteFailed;
                try class_name.format(w, depth, indent + 1, constant_pool);
            },
            .field_ref => |field_ref| {
                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("class:\n");
                const class = field_ref.class(constant_pool) catch return error.WriteFailed;
                try class.format(w, depth, indent + 1, constant_pool);

                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("name_and_type:\n");
                const name_and_type = field_ref.nameAndType(constant_pool) catch return error.WriteFailed;
                try name_and_type.format(w, depth, indent + 1, constant_pool);
            },
            .method_ref => |method_ref| {
                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("class:\n");
                const class = method_ref.class(constant_pool) catch return error.WriteFailed;
                try class.format(w, depth, indent + 1, constant_pool);

                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("name_and_type:\n");
                const name_and_type = method_ref.nameAndType(constant_pool) catch return error.WriteFailed;
                try name_and_type.format(w, depth, indent + 1, constant_pool);
            },
            .interface_method_ref => |interface_method_ref| {
                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("class:\n");
                const class = interface_method_ref.class(constant_pool) catch return error.WriteFailed;
                try class.format(w, depth, indent + 1, constant_pool);

                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("name_and_type:\n");
                const name_and_type = interface_method_ref.nameAndType(constant_pool) catch return error.WriteFailed;
                try name_and_type.format(w, depth, indent + 1, constant_pool);
            },
            .string => |string| {
                const s = string.string(constant_pool) catch return error.WriteFailed;
                try s.format(w, depth, indent + 1, constant_pool);
            },
            .integer => |integer| {
                try w.splatByteAll(' ', depth * indent);
                try w.print("integer: {d}\n", .{ integer.bytes });
            },
            .float => |float| {
                const f: f32 = @bitCast(float.bytes);

                try w.splatByteAll(' ', depth * indent);
                try w.print("float: {d}\n", .{ f });
            },
            .long => |long| {
                const l: u64 = (@as(u64, long.high_bytes) << 32) | long.low_bytes;

                try w.splatByteAll(' ', depth * indent);
                try w.print("long: {d}\n", .{ l });
            },
            .double => |double| {
                const l: u64 = (@as(u64, double.high_bytes) << 32) | double.low_bytes;
                const d: f64 = @bitCast(l);

                try w.splatByteAll(' ', depth * indent);
                try w.print("double: {d}\n", .{ d });
            },
            .name_and_type => |name_and_type| {
                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("name:\n");
                const name = name_and_type.name(constant_pool) catch return error.WriteFailed;
                try name.format(w, depth, indent + 1, constant_pool);

                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("descriptor:\n");
                const descriptor = name_and_type.descriptor(constant_pool) catch return error.WriteFailed;
                try descriptor.format(w, depth, indent + 1, constant_pool);
            },
            .utf8 => |utf8| {
                try w.splatByteAll(' ', depth * indent);
                try w.print("bytes: \"{s}\"\n", .{ utf8.bytes });
            },
            .method_handle => |method_handle| {
                try w.splatByteAll(' ', depth * indent);
                try w.print("kind: {t}\n", .{ method_handle.reference_kind });

                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("reference:\n");
                const reference = method_handle.reference(constant_pool) catch return error.WriteFailed;
                try reference.format(w, depth, indent + 1, constant_pool);
            },
            .method_type => |method_type| {
                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("descriptor:\n");
                const descriptor = method_type.descriptor(constant_pool) catch return error.WriteFailed;
                try descriptor.format(w, depth, indent + 1, constant_pool);
            },
            .invoke_dynamic => |invoke_dynamic| {
                try w.splatByteAll(' ', depth * indent);
                _ = try w.write("name_and_type:\n");
                const name_and_type = invoke_dynamic.nameAndType(constant_pool) catch return error.WriteFailed;
                try name_and_type.format(w, depth, indent + 1, constant_pool);
            },
        }
    }
};

pub const ClassFlags = enum(u16) {
    public = 0x0001,
    final = 0x0010,
    super = 0x0020,
    interface = 0x0200,
    abstract = 0x0400,
    synthetic = 0x1000,
    annotation = 0x2000,
    @"enum" = 0x4000,
};

pub const ClassAccessFlags = EnumFlags(ClassFlags);

pub const FieldInfo = struct {
    access_flags: FieldAccessFlags,
    name_index: u16,
    descriptor_index: u16,
    attributes: []AttributeInfo,

    pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) !FieldInfo {
        const access_flags: FieldAccessFlags = .{ .mask = try input.takeInt(u16, .big) };
        const name_index = try input.takeInt(u16, .big);
        const descriptor_index = try input.takeInt(u16, .big);
        const attributes = try parseAttributes(input, allocator);
        return .{
            .access_flags = access_flags,
            .name_index = name_index,
            .descriptor_index = descriptor_index,
            .attributes = attributes,
        };
    }

    pub fn deinit(self: *FieldInfo, allocator: std.mem.Allocator) void {
        for (self.attributes) |*attr_info| {
            attr_info.deinit(allocator);
        }
        allocator.free(self.attributes);
    }

    pub fn format(self: *const FieldInfo, w: *std.Io.Writer, depth: usize, indent: u8, allocator: std.mem.Allocator, constant_pool: []const ?CpInfo) std.Io.Writer.Error!void {
        try w.splatByteAll(' ', depth * indent);
        try w.print("flags: {f}\n", .{ self.access_flags });

        try w.splatByteAll(' ', depth * indent);
        _ = try w.write("name:\n");
        const field_name = self.name(constant_pool) catch return error.WriteFailed;
        try field_name.format(w, depth, indent + 1, constant_pool);

        try w.splatByteAll(' ', depth * indent);
        _ = try w.write("descriptor:\n");
        const field_descriptor = self.descriptor(constant_pool) catch return error.WriteFailed;
        try field_descriptor.format(w, depth, indent + 1, constant_pool);

        try w.splatByteAll(' ', depth * indent);
        _ = try w.write("attributes:\n");
        var attr_indent = indent;
        for (self.attributes, 0..) |*attribute, j| {
            attr_indent += 1;
            defer attr_indent -= 1;

            try w.splatByteAll(' ', depth * attr_indent);
            try w.print("{d}:\n", .{ j });

            try attribute.format(w, depth, attr_indent + 1, allocator, constant_pool);
        }
    }

    pub fn name(self: *const FieldInfo, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
        const name_index = self.name_index - 1;
        if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
        const cp_info = constant_pool[name_index];
        if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
        return cp_info.?;
    }

    pub fn descriptor(self: *const FieldInfo, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
        const descriptor_index = self.descriptor_index - 1;
        if (descriptor_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
        const cp_info = constant_pool[descriptor_index];
        if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
        return cp_info.?;
    }
};

pub const FieldFlags = enum(u16) {
    public = 0x0001,
    private = 0x0002,
    protected = 0x0004,
    static = 0x0008,
    final = 0x0010,
    @"volatile" = 0x0040,
    transient = 0x0080,
    synthetic = 0x1000,
    @"enum" = 0x4000,
};

pub const FieldAccessFlags = EnumFlags(FieldFlags);

pub const MethodInfo = struct {
    access_flags: MethodAccessFlags,
    name_index: u16,
    descriptor_index: u16,
    attributes: []AttributeInfo,

    pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) !MethodInfo {
        const access_flags: MethodAccessFlags = .{ .mask = try input.takeInt(u16, .big) };
        const name_index = try input.takeInt(u16, .big);
        const descriptor_index = try input.takeInt(u16, .big);
        const attributes = try parseAttributes(input, allocator);
        return .{
            .access_flags = access_flags,
            .name_index = name_index,
            .descriptor_index = descriptor_index,
            .attributes = attributes,
        };
    }

    pub fn deinit(self: *MethodInfo, allocator: std.mem.Allocator) void {
        for (self.attributes) |*attr_info| {
            attr_info.deinit(allocator);
        }
        allocator.free(self.attributes);
    }

    pub fn format(self: *const MethodInfo, w: *std.Io.Writer, depth: usize, indent: u8, allocator: std.mem.Allocator, constant_pool: []const ?CpInfo) std.Io.Writer.Error!void {
        try w.splatByteAll(' ', depth * indent);
        try w.print("flags: {f}\n", .{ self.access_flags });

        try w.splatByteAll(' ', depth * indent);
        _ = try w.write("name:\n");
        const method_name = self.name(constant_pool) catch return error.WriteFailed;
        try method_name.format(w, depth, indent + 1, constant_pool);

        try w.splatByteAll(' ', depth * indent);
        _ = try w.write("descriptor:\n");
        const method_descriptor = self.descriptor(constant_pool) catch return error.WriteFailed;
        try method_descriptor.format(w, depth, indent + 1, constant_pool);

        try w.splatByteAll(' ', depth * indent);
        _ = try w.write("attributes:\n");
        var attr_indent = indent;
        for (self.attributes, 0..) |*attribute, j| {
            attr_indent += 1;
            defer attr_indent -= 1;

            try w.splatByteAll(' ', depth * attr_indent);
            try w.print("{d}:\n", .{ j });

            try attribute.format(w, depth, attr_indent + 1, allocator, constant_pool);
        }
    }

    pub fn name(self: *const MethodInfo, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
        const name_index = self.name_index - 1;
        if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
        const cp_info = constant_pool[name_index];
        if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
        return cp_info.?;
    }

    pub fn descriptor(self: *const MethodInfo, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
        const descriptor_index = self.descriptor_index - 1;
        if (descriptor_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
        const cp_info = constant_pool[descriptor_index];
        if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
        return cp_info.?;
    }
};

pub const MethodFlags = enum(u16) {
    public = 0x0001,
    private = 0x0002,
    protected = 0x0004,
    static = 0x0008,
    final = 0x0010,
    synchronized = 0x0020,
    bridge = 0x0040,
    varargs = 0x0080,
    native = 0x0100,
    abstract = 0x0400,
    strict = 0x0800,
    synthetic = 0x1000,
};

pub const MethodAccessFlags = EnumFlags(MethodFlags);

pub const AttributeInfo = struct {
    attribute_name_index: u16,
    info: []u8,

    pub const Predefined = union(enum) {
        constant_value: ConstantValue,
        code: Code,
        stack_map_table: StackMapTable,
        exceptions: Exceptions,
        inner_classes: InnerClasses,
        enclosing_method: EnclosingMethod,
        synthetic: Synthetic,
        signature: Signature,
        source_file: SourceFile,
        source_debug_extension: SourceDebugExtension,
        line_number_table: LineNumberTable,
        local_variable_table: LocalVariableTable,
        local_variable_type_table: LocalVariableTypeTable,
        deprecated: Deprecated,
        runtime_visible_annotations: RuntimeVisibleAnnotations,
        runtime_invisible_annotations: RuntimeInvisibleAnnotations,
        runtime_visible_parameter_annotations: RuntimeVisibleParameterAnnotations,
        runtime_invisible_parameter_annotations: RuntimeInvisibleParameterAnnotations,
        annotation_default: AnnotationDefault,
        bootstrap_methods: BootstrapMethods,

        pub const ConstantValue = struct {
            constant_value_index: u16,

            pub fn constantValue(self: *const ConstantValue, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
                const constant_value_index = self.constant_value_index - 1;
                if (constant_value_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
                const cp_info = constant_pool[constant_value_index];
                if (cp_info == null) return ResolveError.InvalidConstantType;

                return cp_info.?;
            }
        };

        pub const Code = struct {
            max_stack: u16,
            max_locals: u16,
            code: []u8,
            exception_table: []ExceptionHandler,
            attributes: []AttributeInfo,

            pub const ExceptionHandler = struct {
                start_pc: u16,
                end_pc: u16,
                handler_pc: u16,
                catch_type: u16,
            };
        };

        pub const StackMapTable = struct {
            entries: []StackMapFrame,

            pub const StackMapFrame = union(enum) {
                // 0-63
                same_frame,
                // 64-127
                same_locals_1_stack_item_frame: struct {
                    stack: [1]VerificationTypeInfo,
                },
                // 247
                same_locals_1_stack_item_frame_extended: struct {
                    offset_delta: u16,
                    stack: [1]VerificationTypeInfo,
                },
                // 248-250
                chop_frame: struct {
                    offset_delta: u16,
                },
                // 251
                same_frame_extended: struct {
                    offset_delta: u16,
                },
                // 252-254
                append_frame: struct {
                    offset_delta: u16,
                    locals: []const VerificationTypeInfo,
                },
                // 255
                full_frame: struct {
                    offset_delta: u16,
                    locals: []const VerificationTypeInfo,
                    stack: []const VerificationTypeInfo,
                },

                pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError!StackMapFrame {
                    const frame_type = try input.takeByte();
                    return switch (frame_type) {
                        0...63 => .same_frame,
                        64...127 => .{
                            .same_locals_1_stack_item_frame = .{
                                .stack = .{ try .parse(input) },
                            },
                        },
                        247 => .{
                            .same_locals_1_stack_item_frame_extended = .{
                                .offset_delta = try input.takeInt(u16, .big),
                                .stack = .{ try .parse(input) },
                            },
                        },
                        248...250 => .{
                            .chop_frame = .{
                                .offset_delta = try input.takeInt(u16, .big),
                            },
                        },
                        252...254 => blk: {
                            const offset_delta = try input.takeInt(u16, .big);

                            const length = frame_type - 251;
                            const locals = try allocator.alloc(Predefined.StackMapTable.VerificationTypeInfo, length);
                            errdefer allocator.free(locals);
                            for (locals) |*local| {
                                local.* = try .parse(input);
                            }

                            break :blk .{
                                .append_frame = .{
                                    .offset_delta = offset_delta,
                                    .locals = locals,
                                },
                            };
                        },
                        255 => blk: {
                            const offset_delta = try input.takeInt(u16, .big);

                            const number_of_locals = try input.takeInt(u16, .big);
                            const locals = try allocator.alloc(Predefined.StackMapTable.VerificationTypeInfo, number_of_locals);
                            errdefer allocator.free(locals);
                            for (locals) |*local| {
                                local.* = try .parse(input);
                            }

                            const number_of_stack_items = try input.takeInt(u16, .big);
                            const stack = try allocator.alloc(Predefined.StackMapTable.VerificationTypeInfo, number_of_stack_items);
                            errdefer allocator.free(stack);
                            for (stack) |*stack_item| {
                                stack_item.* = try .parse(input);
                            }

                            break :blk .{
                                .full_frame = .{
                                    .offset_delta = offset_delta,
                                    .locals = locals,
                                    .stack = stack,
                                },
                            };
                        },
                        else => unreachable,
                    };
                }

                pub fn deinit(self: *StackMapFrame, allocator: std.mem.Allocator) void {
                    switch (self.*) {
                        .append_frame => |frame| allocator.free(frame.locals),
                        .full_frame => |frame| {
                            allocator.free(frame.locals);
                            allocator.free(frame.stack);
                        },
                        else => {},
                    }
                }
            };

            pub const VerificationTypeInfo = union(VerificationTypeInfo.Tag) {
                top,
                integer,
                float,
                double,
                long,
                null,
                uninitialized_this,
                object: struct {
                    cpool_index: u16,
                },
                uninitialized: struct {
                    cpool_index: u16,
                },

                pub const Tag = enum(u8) {
                    top = 0,
                    integer = 1,
                    float = 2,
                    double = 3,
                    long = 4,
                    null = 5,
                    uninitialized_this = 6,
                    object = 7,
                    uninitialized = 8,
                };

                pub fn parse(input: *std.Io.Reader) ParseError!VerificationTypeInfo {
                    const tag_byte = try input.takeByte();
                    const tag = std.enums.fromInt(Predefined.StackMapTable.VerificationTypeInfo.Tag, tag_byte) orelse return ParseError.InvalidTag;

                    return switch (tag) {
                        .top => .top,
                        .integer => .integer,
                        .float => .float,
                        .double => .double,
                        .long => .long,
                        .null => .null,
                        .uninitialized_this => .uninitialized_this,
                        .object => .{
                            .object = .{
                                .cpool_index = try input.takeInt(u16, .big),
                            },
                        },
                        .uninitialized => .{
                            .uninitialized = .{
                                .cpool_index = try input.takeInt(u16, .big),
                            },
                        },
                    };
                }
            };
        };

        pub const Exceptions = struct {
            exception_index_table: []u16,
        };

        pub const InnerClasses = struct {
            classes: []InnerClass,

            pub const InnerClass = struct {
                inner_class_info_index: u16,
                outer_class_info_index: u16,
                inner_name_index: u16,
                inner_class_access_flags: InnerClassAccessFlags,

                pub fn format(self: *const InnerClass, w: *std.Io.Writer, depth: usize, indent: u8, constant_pool: []const ?CpInfo) std.Io.Writer.Error!void {
                    try w.splatByteAll(' ', depth * indent);
                    try w.print("flags: {f}\n", .{ self.inner_class_access_flags });

                    const inner_class = self.innerClass(constant_pool) catch return error.WriteFailed;
                    try w.splatByteAll(' ', depth * indent);
                    _ = try w.write("inner_class:\n");
                    try inner_class.format(w, depth, indent + 1, constant_pool);

                    const outer_class = self.outerClass(constant_pool) catch return error.WriteFailed;
                    if (outer_class) |oc| {
                        try w.splatByteAll(' ', depth * indent);
                        _ = try w.write("outer_class:\n");
                        try oc.format(w, depth, indent + 1, constant_pool);
                    }

                    const inner_name = self.innerName(constant_pool) catch return error.WriteFailed;
                    if (inner_name) |in| {
                        try w.splatByteAll(' ', depth * indent);
                        _ = try w.write("inner_name:\n");
                        try in.format(w, depth, indent + 1, constant_pool);
                    }
                }

                pub fn innerClass(self: *const InnerClass, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
                    const inner_class_info_index = self.inner_class_info_index - 1;
                    if (inner_class_info_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
                    const cp_info = constant_pool[inner_class_info_index];
                    if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
                    return cp_info.?;
                }

                pub fn outerClass(self: *const InnerClass, constant_pool: []const ?CpInfo) ResolveError!?CpInfo {
                    if (self.outer_class_info_index == 0) return null;
                    const outer_class_info_index = self.outer_class_info_index - 1;
                    if (outer_class_info_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;

                    const cp_info = constant_pool[outer_class_info_index];
                    if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
                    return cp_info.?;
                }

                pub fn innerName(self: *const InnerClass, constant_pool: []const ?CpInfo) ResolveError!?CpInfo {
                    if (self.inner_name_index == 0) return null;
                    const inner_name_index = self.inner_name_index - 1;
                    if (inner_name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;

                    const cp_info = constant_pool[inner_name_index];
                    if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
                    return cp_info.?;
                }
            };

            pub const InnerClassFlags = enum(u16) {
                public = 0x0001,
                private = 0x0002,
                protected = 0x0004,
                static = 0x0008,
                final = 0x0010,
                interface = 0x0200,
                abstract = 0x0400,
                synthetic = 0x1000,
                annotation = 0x2000,
                @"enum" = 0x4000,
            };

            pub const InnerClassAccessFlags = EnumFlags(InnerClassFlags);
        };

        pub const EnclosingMethod = struct {
            class_index: u16,
            method_index: u16,

            pub fn class(self: *const EnclosingMethod, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
                const class_index = self.class_index - 1;
                if (class_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
                const cp_info = constant_pool[class_index];
                if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
                return cp_info.?;
            }

            pub fn method(self: *const EnclosingMethod, constant_pool: []const ?CpInfo) ResolveError!?CpInfo {
                if (self.method_index == 0) return null;
                const method_index = self.method_index - 1;
                if (method_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
                const cp_info = constant_pool[method_index];
                if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
                return cp_info.?;
            }
        };

        pub const Synthetic = struct { };

        pub const Signature = struct {
            signature_index: u16,

            pub fn signature(self: *const Signature, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
                const signature_index = self.signature_index - 1;
                if (signature_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
                const cp_info = constant_pool[signature_index];
                if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
                return cp_info.?;
            }
        };

        pub const SourceFile = struct {
            source_file_index: u16,

            pub fn sourceFile(self: *const SourceFile, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
                const source_file_index = self.source_file_index - 1;
                if (source_file_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
                const cp_info = constant_pool[source_file_index];
                if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
                return cp_info.?;
            }
        };

        pub const SourceDebugExtension = struct {
            debug_extension: []u8,
        };

        pub const LineNumberTable = struct {
            line_number_table: []const LineNumber,

            pub const LineNumber = struct {
                start_pc: u16,
                line_number: u16,
            };
        };

        pub const LocalVariableTable = struct {
            local_variable_table: []LocalVariable,

            pub const LocalVariable = struct {
                start_pc: u16,
                length: u16,
                name_index: u16,
                descriptor_index: u16,
                index: u16,
            };
        };

        pub const LocalVariableTypeTable = struct {
            local_variable_type_table: []LocalVariableType,

            pub const LocalVariableType = struct {
                start_pc: u16,
                length: u16,
                name_index: u16,
                signature_index: u16,
                index: u16,
            };
        };

        pub const Deprecated = struct { };

        pub const ElementValue = union(enum) {
            // B, C, D, F, I, J, S, Z, s
            const_value_index: u16,
            // e
            enum_const_value: struct {
                type_name_index: u16,
                const_name_index: u16,
            },
            // c
            class_info_index: u16,
            // @
            annotation_value: Annotation,
            // [
            array_value: struct {
                values: []ElementValue,
            },

            pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError!ElementValue {
                const tag = try input.takeByte();
                return switch (tag) {
                    'B', 'C', 'D', 'F', 'I', 'J', 'S', 'Z', 's' => .{
                        .const_value_index = try input.takeInt(u16, .big),
                    },
                    'e' => .{
                        .enum_const_value = .{
                            .type_name_index = try input.takeInt(u16, .big),
                            .const_name_index = try input.takeInt(u16, .big),
                        },
                        },
                    'c' => .{
                        .class_info_index = try input.takeInt(u16, .big),
                    },
                    '@' => .{
                        .annotation_value = try .parse(input, allocator),
                    },
                    '[' => .{
                        .array_value = blk: {
                            const num_values = try input.takeInt(u16, .big);
                            const values = try allocator.alloc(ElementValue, num_values);
                            errdefer allocator.free(values);
                            for (values) |*value| {
                                value.* = try .parse(input, allocator);
                            }

                            break :blk .{
                                .values = values,
                            };
                        },
                    },
                    else => unreachable,
                };
            }

            pub fn deinit(self: *ElementValue, allocator: std.mem.Allocator) void {
                switch (self.*) {
                    .annotation_value => |*element_value| element_value.deinit(allocator),
                    .array_value => |element_value| {
                        for (element_value.values) |*value| {
                            value.deinit(allocator);
                        }
                        allocator.free(element_value.values);
                    },
                    else => {},
                }
            }
        };

        pub const Annotation = struct {
            type_index: u16,
            element_value_pairs: []ElementValuePair,

            pub const ElementValuePair = struct {
                element_name_index: u16,
                value: ElementValue,
            };

            pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError!Annotation {
                const type_index = try input.takeInt(u16, .big);

                const num_element_value_pairs = try input.takeInt(u16, .big);
                const element_value_pairs = try allocator.alloc(ElementValuePair, num_element_value_pairs);
                errdefer allocator.free(element_value_pairs);
                for (element_value_pairs) |*element_value_pair| {
                    element_value_pair.* = .{
                        .element_name_index = try input.takeInt(u16, .big),
                        .value = try .parse(input, allocator),
                    };
                }

                return .{
                    .type_index = type_index,
                    .element_value_pairs = element_value_pairs,
                };
            }

            pub fn deinit(self: *Annotation, allocator: std.mem.Allocator) void {
                for (self.element_value_pairs) |*element_value_pair| {
                    element_value_pair.value.deinit(allocator);
                }
                allocator.free(self.element_value_pairs);
            }
        };

        pub const RuntimeVisibleAnnotations = struct {
            annotations: []Annotation,
        };

        pub const RuntimeInvisibleAnnotations = struct {
            annotations: []Annotation,
        };

        pub const ParameterAnnotation = struct {
            annotations: []Annotation,
        };

        pub const RuntimeVisibleParameterAnnotations = struct {
            parameter_annotations: []ParameterAnnotation,
        };

        pub const RuntimeInvisibleParameterAnnotations = struct {
            parameter_annotations: []ParameterAnnotation,
        };

        pub const AnnotationDefault = struct {
            default_value: ElementValue,
        };

        pub const BootstrapMethods = struct {
            bootstrap_methods: []BootstrapMethod,

            pub const BootstrapMethod = struct {
                bootstrap_method_ref: u16,
                bootstrap_arguments: []u16,
            };
        };

        pub fn deinit(self: *Predefined, allocator: std.mem.Allocator) void {
            switch (self.*) {
                .code => |attribute| {
                    allocator.free(attribute.code);
                    allocator.free(attribute.exception_table);
                    for (attribute.attributes) |*attr| {
                        attr.deinit(allocator);
                    }
                    allocator.free(attribute.attributes);
                },
                .stack_map_table => |attribute| {
                    for (attribute.entries) |*entry| {
                        entry.deinit(allocator);
                    }
                    allocator.free(attribute.entries);
                },
                .exceptions => |attribute| allocator.free(attribute.exception_index_table),
                .inner_classes => |attribute| allocator.free(attribute.classes),
                .source_debug_extension => |attribute| allocator.free(attribute.debug_extension),
                .line_number_table => |attribute| allocator.free(attribute.line_number_table),
                .local_variable_table => |attribute| allocator.free(attribute.local_variable_table),
                .local_variable_type_table => |attribute| allocator.free(attribute.local_variable_type_table),
                .runtime_visible_annotations => |attribute| {
                    for (attribute.annotations) |*annotation| {
                        annotation.deinit(allocator);
                    }
                    allocator.free(attribute.annotations);
                },
                .runtime_invisible_annotations => |attribute| {
                    for (attribute.annotations) |*annotation| {
                        annotation.deinit(allocator);
                    }
                    allocator.free(attribute.annotations);
                },
                .runtime_visible_parameter_annotations => |attribute| {
                    for (attribute.parameter_annotations) |parameter_annotation| {
                        for (parameter_annotation.annotations) |*annotation| {
                            annotation.deinit(allocator);
                        }
                        allocator.free(parameter_annotation.annotations);
                    }
                    allocator.free(attribute.parameter_annotations);
                },
                .runtime_invisible_parameter_annotations => |attribute| {
                    for (attribute.parameter_annotations) |parameter_annotation| {
                        for (parameter_annotation.annotations) |*annotation| {
                            annotation.deinit(allocator);
                        }
                        allocator.free(parameter_annotation.annotations);
                    }
                    allocator.free(attribute.parameter_annotations);
                },
                .bootstrap_methods => |attribute| {
                    for (attribute.bootstrap_methods) |bootstrap_method| {
                        allocator.free(bootstrap_method.bootstrap_arguments);
                    }
                    allocator.free(attribute.bootstrap_methods);
                },
                else => {},
            }
        }
    };

    pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError!AttributeInfo {
        const attribute_name_index = try input.takeInt(u16, .big);
        const attribute_length = try input.takeInt(u32, .big);
        const info = try input.readAlloc(allocator, attribute_length);
        return .{
            .attribute_name_index = attribute_name_index,
            .info = info,
        };
    }

    pub fn deinit(self: *AttributeInfo, allocator: std.mem.Allocator) void {
        allocator.free(self.info);
    }

    pub fn format(self: *const AttributeInfo, w: *std.Io.Writer, depth: usize, indent: u8, allocator: std.mem.Allocator, constant_pool: []const ?CpInfo) std.Io.Writer.Error!void {
        try w.splatByteAll(' ', depth * indent);
        _ = try w.write("name:\n");
        const attribute_name = self.attributeName(constant_pool) catch return error.WriteFailed;
        try attribute_name.format(w, depth, indent + 1, constant_pool);

        var predefined = self.resolve(allocator, constant_pool) catch return error.WriteFailed;
        if (predefined) |*p| {
            defer p.deinit(allocator);

            try w.splatByteAll(' ', depth * indent);
            _ = try w.write("predefined: yes\n");

            try w.splatByteAll(' ', depth * indent);
            try w.print("type: {s}\n", .{ @tagName(p.*) });

            switch (p.*) {
                .constant_value => |attr| {
                    const constant_value = attr.constantValue(constant_pool) catch return error.WriteFailed;
                    try constant_value.format(w, depth, indent + 1, constant_pool);
                },
                .code => |attr| {
                    try w.splatByteAll(' ', depth * indent);
                    try w.print("max_stack: {d}\n", .{ attr.max_stack });

                    try w.splatByteAll(' ', depth * indent);
                    try w.print("max_locals: {d}\n", .{ attr.max_locals });

                    try w.splatByteAll(' ', depth * indent);
                    _ = try w.write("code:\n");
                    var instr_indent = indent;
                    for (attr.code, 0..) |instr, i| {
                        instr_indent += 1;
                        defer instr_indent -= 1;

                        try w.splatByteAll(' ', depth * instr_indent);
                        try w.print("{d}: 0x{x}\n", .{ i, instr });
                    }

                    //try w.splatByteAll(' ', depth * indent);
                    //_ = try w.write("exception_table:\n");
                    //var exception_indent = indent;
                    //for (attr.exception_table, 0..) |*exception, i| {
                    //    exception_indent += 1;
                    //    defer exception_indent -= 1;

                    //    try w.splatByteAll(' ', depth * exception_indent);
                    //    try w.print("{d}:\n", .{ i });

                    //    try self.formatExceptionHandler(w, depth, exception_indent + 1, exception);
                    //}

                    try w.splatByteAll(' ', depth * indent);
                    _ = try w.write("attributes:\n");
                    var attr_indent = indent;
                    for (attr.attributes, 0..) |*a, i| {
                        attr_indent += 1;
                        defer attr_indent -= 1;

                        try w.splatByteAll(' ', depth * attr_indent);
                        try w.print("{d}:\n", .{ i });

                        try a.format(w, depth, attr_indent + 1, allocator, constant_pool);
                    }
                },
                //.stack_map_table,
                .exceptions => |attr| {
                    try w.splatByteAll(' ', depth * indent);
                    _ = try w.write("exceptions:\n");
                    var exception_indent = indent;
                    for (attr.exception_index_table, 0..) |exception, i| {
                        exception_indent += 1;
                        defer exception_indent -= 1;

                        if (exception >= constant_pool.len) return error.WriteFailed;
                        const cp_info = constant_pool[exception - 1];
                        if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .class) return error.WriteFailed;

                        try w.splatByteAll(' ', depth * exception_indent);
                        try w.print("{d}:\n", .{ i });
                        try cp_info.?.format(w, depth, exception_indent + 1, constant_pool);
                    }
                },
                .inner_classes => |attr| {
                    try w.splatByteAll(' ', depth * indent);
                    _ = try w.write("classes:\n");
                    var class_indent = indent;
                    for (attr.classes, 0..) |*class, i| {
                        class_indent += 1;
                        defer class_indent -= 1;

                        try w.splatByteAll(' ', depth * class_indent);
                        try w.print("{d}:\n", .{ i });
                        try class.format(w, depth, class_indent + 1, constant_pool);
                    }
                },
                .enclosing_method => |attr| {
                    const class = attr.class(constant_pool) catch return error.WriteFailed;
                    try w.splatByteAll(' ', depth * indent);
                    _ = try w.write("class:\n");
                    try class.format(w, depth, indent + 1, constant_pool);

                    const method = attr.method(constant_pool) catch return error.WriteFailed;
                    if (method) |m| {
                        try w.splatByteAll(' ', depth * indent);
                        _ = try w.write("method:\n");
                        try m.format(w, depth, indent + 1, constant_pool);
                    }
                },
                .synthetic => {},
                .signature => |attr| {
                    const signature = attr.signature(constant_pool) catch return error.WriteFailed;
                    try signature.format(w, depth, indent + 1, constant_pool);
                },
                .source_file => |attr| {
                    const source_file = attr.sourceFile(constant_pool) catch return error.WriteFailed;
                    try source_file.format(w, depth, indent + 1, constant_pool);
                },
                //.source_debug_extension,
                //.line_number_table,
                //.local_variable_table,
                //.local_variable_type_table,
                .deprecated => {},
                //.runtime_visible_annotations,
                //.runtime_invisible_annotations,
                //.runtime_visible_parameter_annotations,
                //.runtime_invisible_parameter_annotations,
                //.annotation_default,
                //.bootstrap_methods,
                else => {},
            }
        } else {
            try w.splatByteAll(' ', depth * indent);
            _ = try w.write("predefined: no\n");
        }
    }

    pub fn attributeName(self: *const AttributeInfo, constant_pool: []const ?CpInfo) ResolveError!CpInfo {
        const attribute_name_index = self.attribute_name_index - 1;
        if (attribute_name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
        const cp_info = constant_pool[attribute_name_index];
        if (cp_info == null or @as(CpInfo.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
        return cp_info.?;
    }

    pub fn resolve(self: *const AttributeInfo, allocator: std.mem.Allocator, constant_pool: []const ?CpInfo) (ResolveError || ParseError)!?Predefined {
        const attribute_name = (try self.attributeName(constant_pool)).utf8;

        var r: std.Io.Reader = .fixed(self.info);

        const eql = std.mem.eql;
        if (eql(u8, attribute_name.bytes, "ConstantValue")) {
            return .{
                .constant_value = .{
                    .constant_value_index = try r.takeInt(u16, .big),
                },
            };
        } else if (eql(u8, attribute_name.bytes, "Code")) {
            const max_stack = try r.takeInt(u16, .big);
            const max_locals = try r.takeInt(u16, .big);

            const code_length = try r.takeInt(u32, .big);
            const code = try r.readAlloc(allocator, code_length);
            errdefer allocator.free(code);

            const exception_table_length = try r.takeInt(u16, .big);
            const exception_table = try allocator.alloc(Predefined.Code.ExceptionHandler, exception_table_length);
            errdefer allocator.free(exception_table);
            for (exception_table) |*exception_handler| {
                exception_handler.* = .{
                    .start_pc = try r.takeInt(u16, .big),
                    .end_pc = try r.takeInt(u16, .big),
                    .handler_pc = try r.takeInt(u16, .big),
                    .catch_type = try r.takeInt(u16, .big),
                };
            }

            const attribute_count = try r.takeInt(u16, .big);
            const attributes = try allocator.alloc(AttributeInfo, attribute_count);
            errdefer allocator.free(attributes);
            for (attributes) |*attribute| {
                attribute.* = try .parse(&r, allocator);
            }

            return .{
                .code = .{
                    .max_stack = max_stack,
                    .max_locals = max_locals,
                    .code = code,
                    .exception_table = exception_table,
                    .attributes = attributes,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "StackMapTable")) {
            const number_of_entries = try r.takeInt(u16, .big);
            const entries = try allocator.alloc(Predefined.StackMapTable.StackMapFrame, number_of_entries);
            errdefer allocator.free(entries);
            for (entries) |*entry| {
                entry.* = try .parse(&r, allocator);
            }

            return .{
                .stack_map_table = .{
                    .entries = entries,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "Exceptions")) {
            const number_of_exceptions = try r.takeInt(u16, .big);
            const exception_index_table = try allocator.alloc(u16, number_of_exceptions);
            errdefer allocator.free(exception_index_table);
            for (exception_index_table) |*exception_index| {
                exception_index.* = try r.takeInt(u16, .big);
            }

            return .{
                .exceptions = .{
                    .exception_index_table = exception_index_table,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "InnerClasses")) {
            const number_of_classes = try r.takeInt(u16, .big);
            const classes = try allocator.alloc(Predefined.InnerClasses.InnerClass, number_of_classes);
            errdefer allocator.free(classes);
            for (classes) |*class| {
                class.* = .{
                    .inner_class_info_index = try r.takeInt(u16, .big),
                    .outer_class_info_index = try r.takeInt(u16, .big),
                    .inner_name_index = try r.takeInt(u16, .big),
                    .inner_class_access_flags = .{ .mask = try r.takeInt(u16, .big) },
                };
            }

            return .{
                .inner_classes = .{
                    .classes = classes,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "EnclosingMethod")) {
            return .{
                .enclosing_method = .{
                    .class_index = try r.takeInt(u16, .big),
                    .method_index = try r.takeInt(u16, .big),
                },
            };
        } else if (eql(u8, attribute_name.bytes, "Synthetic")) {
            return .{
                .synthetic = .{},
            };
        } else if (eql(u8, attribute_name.bytes, "Signature")) {
            return .{
                .signature = .{
                    .signature_index = try r.takeInt(u16, .big),
                },
            };
        } else if (eql(u8, attribute_name.bytes, "SourceFile")) {
            return .{
                .source_file = .{
                    .source_file_index = try r.takeInt(u16, .big),
                },
            };
        } else if (eql(u8, attribute_name.bytes, "SourceDebugExtension")) {
            return .{
                .source_debug_extension = .{
                    .debug_extension = try allocator.dupe(u8, self.info),
                },
            };
        } else if (eql(u8, attribute_name.bytes, "LineNumberTable")) {
            const line_number_table_length = try r.takeInt(u16, .big);
            const line_number_table = try allocator.alloc(Predefined.LineNumberTable.LineNumber, line_number_table_length);
            errdefer allocator.free(line_number_table);
            for (line_number_table) |*line_number| {
                line_number.* = .{
                    .start_pc = try r.takeInt(u16, .big),
                    .line_number = try r.takeInt(u16, .big),
                };
            }

            return .{
                .line_number_table = .{
                    .line_number_table = line_number_table,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "LocalVariableTable")) {
            const local_variable_table_length = try r.takeInt(u16, .big);
            const local_variable_table = try allocator.alloc(Predefined.LocalVariableTable.LocalVariable, local_variable_table_length);
            errdefer allocator.free(local_variable_table);
            for (local_variable_table) |*local_variable| {
                local_variable.* = .{
                    .start_pc = try r.takeInt(u16, .big),
                    .length = try r.takeInt(u16, .big),
                    .name_index = try r.takeInt(u16, .big),
                    .descriptor_index = try r.takeInt(u16, .big),
                    .index = try r.takeInt(u16, .big),
                };
            }

            return .{
                .local_variable_table = .{
                    .local_variable_table = local_variable_table,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "LocalVariableTypeTable")) {
            const local_variable_type_table_length = try r.takeInt(u16, .big);
            const local_variable_type_table = try allocator.alloc(Predefined.LocalVariableTypeTable.LocalVariableType, local_variable_type_table_length);
            errdefer allocator.free(local_variable_type_table);
            for (local_variable_type_table) |*local_variable_type| {
                local_variable_type.* = .{
                    .start_pc = try r.takeInt(u16, .big),
                    .length = try r.takeInt(u16, .big),
                    .name_index = try r.takeInt(u16, .big),
                    .signature_index = try r.takeInt(u16, .big),
                    .index = try r.takeInt(u16, .big),
                };
            }

            return .{
                .local_variable_type_table = .{
                    .local_variable_type_table = local_variable_type_table,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "Deprecated")) {
            return .{
                .deprecated = .{},
            };
        } else if (eql(u8, attribute_name.bytes, "RuntimeVisibleAnnotations")) {
            const num_annotations = try r.takeInt(u16, .big);
            const annotations = try allocator.alloc(Predefined.Annotation, num_annotations);
            errdefer allocator.free(annotations);
            for (annotations) |*annotation| {
                annotation.* = try .parse(&r, allocator);
            }

            return .{
                .runtime_visible_annotations = .{
                    .annotations = annotations,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "RuntimeInvisibleAnnotations")) {
            const num_annotations = try r.takeInt(u16, .big);
            const annotations = try allocator.alloc(Predefined.Annotation, num_annotations);
            errdefer allocator.free(annotations);
            for (annotations) |*annotation| {
                annotation.* = try .parse(&r, allocator);
            }

            return .{
                .runtime_invisible_annotations = .{
                    .annotations = annotations,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "RuntimeVisibleParameterAnnotations")) {
            const num_parameters = try r.takeByte();
            const parameter_annotations = try allocator.alloc(Predefined.ParameterAnnotation, num_parameters);
            errdefer allocator.free(parameter_annotations);
            for (parameter_annotations) |*parameter_annotation| {
                const num_annotations = try r.takeInt(u16, .big);
                const annotations = try allocator.alloc(Predefined.Annotation, num_annotations);
                errdefer allocator.free(annotations);
                for (annotations) |*annotation| {
                    annotation.* = try .parse(&r, allocator);
                }

                parameter_annotation.* = .{
                    .annotations = annotations,
                };
            }

            return .{
                .runtime_visible_parameter_annotations = .{
                    .parameter_annotations = parameter_annotations,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "RuntimeInvisibleParameterAnnotations")) {
            const num_parameters = try r.takeByte();
            const parameter_annotations = try allocator.alloc(Predefined.ParameterAnnotation, num_parameters);
            errdefer allocator.free(parameter_annotations);
            for (parameter_annotations) |*parameter_annotation| {
                const num_annotations = try r.takeInt(u16, .big);
                const annotations = try allocator.alloc(Predefined.Annotation, num_annotations);
                errdefer allocator.free(annotations);
                for (annotations) |*annotation| {
                    annotation.* = try .parse(&r, allocator);
                }

                parameter_annotation.* = .{
                    .annotations = annotations,
                };
            }

            return .{
                .runtime_invisible_parameter_annotations = .{
                    .parameter_annotations = parameter_annotations,
                },
            };
        } else if (eql(u8, attribute_name.bytes, "AnnotationDefault")) {
            unreachable;
        } else if (eql(u8, attribute_name.bytes, "BootstrapMethods")) {
            const num_bootstrap_methods = try r.takeInt(u16, .big);
            const bootstrap_methods = try allocator.alloc(Predefined.BootstrapMethods.BootstrapMethod, num_bootstrap_methods);
            errdefer allocator.free(bootstrap_methods);
            for (bootstrap_methods) |*bootstrap_method| {
                const bootstrap_method_ref = try r.takeInt(u16, .big);

                const num_bootstrap_arguments = try r.takeInt(u16, .big);
                const bootstrap_arguments = try allocator.alloc(u16, num_bootstrap_arguments);
                errdefer allocator.free(bootstrap_arguments);
                for (bootstrap_arguments) |*bootstrap_argument| {
                    bootstrap_argument.* = try r.takeInt(u16, .big);
                }

                bootstrap_method.* = .{
                    .bootstrap_method_ref = bootstrap_method_ref,
                    .bootstrap_arguments = bootstrap_arguments,
                };
            }

            return .{
                .bootstrap_methods = .{
                    .bootstrap_methods = bootstrap_methods,
                },
            };
        } else {
            return null;
        }
    }
};