pub const Entry = struct {
    version_needed_to_extract: u16,
    flags: GeneralPurposeFlags,
    compression_method: CompressionMethod,
    last_modification_time: u16,
    last_modification_date: u16,
    header_zip_offset: u64,
    crc32: u32,
    filename_len: u32,
    compressed_size: u64,
    uncompressed_size: u64,
    file_offset: u64,

    pub fn extract(
        self: Entry,
        stream: SeekableStream,
        options: ExtractOptions,
        filename_buf: []u8,
        dest: std.fs.Dir,
    ) !u32 {
        if (filename_buf.len < self.filename_len)
            return error.ZipInsufficientBuffer;
        const filename = filename_buf[0..self.filename_len];

        try stream.seekTo(self.header_zip_offset + @sizeOf(CentralDirectoryFileHeader));

        {
            const len = try stream.context.reader().readAll(filename);
            if (len != filename.len)
                return error.ZipBadFileOffset;
        }

        const local_data_header_offset: u64 = local_data_header_offset: {
            const local_header = blk: {
                try stream.seekTo(self.file_offset);
                break :blk try stream.context.reader().readStructEndian(LocalFileHeader, .little);
            };
            if (!std.mem.eql(u8, &local_header.signature, &local_file_header_sig))
                return error.ZipBadFileOffset;
            if (local_header.version_needed_to_extract != self.version_needed_to_extract)
                return error.ZipMismatchVersionNeeded;
            if (local_header.last_modification_time != self.last_modification_time)
                return error.ZipMismatchModTime;
            if (local_header.last_modification_date != self.last_modification_date)
                return error.ZipMismatchModDate;

            if (@as(u16, @bitCast(local_header.flags)) != @as(u16, @bitCast(self.flags)))
                return error.ZipMismatchFlags;
            if (local_header.crc32 != 0 and local_header.crc32 != self.crc32)
                return error.ZipMismatchCrc32;
            var extents: FileExtents = .{
                .uncompressed_size = local_header.uncompressed_size,
                .compressed_size = local_header.compressed_size,
                .local_file_header_offset = 0,
            };
            if (local_header.extra_len > 0) {
                var extra_buf: [std.math.maxInt(u16)]u8 = undefined;
                const extra = extra_buf[0..local_header.extra_len];

                {
                    try stream.seekTo(self.file_offset + @sizeOf(LocalFileHeader) + local_header.filename_len);
                    const len = try stream.context.reader().readAll(extra);
                    if (len != extra.len)
                        return error.ZipTruncated;
                }

                var extra_offset: usize = 0;
                while (extra_offset + 4 <= local_header.extra_len) {
                    const header_id = std.mem.readInt(u16, extra[extra_offset..][0..2], .little);
                    const data_size = std.mem.readInt(u16, extra[extra_offset..][2..4], .little);
                    const end = extra_offset + 4 + data_size;
                    if (end > local_header.extra_len)
                        return error.ZipBadExtraFieldSize;
                    const data = extra[extra_offset + 4 .. end];
                    switch (@as(ExtraHeader, @enumFromInt(header_id))) {
                        .zip64_info => try readZip64FileExtents(LocalFileHeader, local_header, &extents, data),
                        else => {}, // ignore
                    }
                    extra_offset = end;
                }
            }

            if (extents.compressed_size != 0 and
                extents.compressed_size != self.compressed_size)
                return error.ZipMismatchCompLen;
            if (extents.uncompressed_size != 0 and
                extents.uncompressed_size != self.uncompressed_size)
                return error.ZipMismatchUncompLen;

            if (local_header.filename_len != self.filename_len)
                return error.ZipMismatchFilenameLen;

            break :local_data_header_offset @as(u64, local_header.filename_len) +
                @as(u64, local_header.extra_len);
        };

        if (isBadFilename(filename))
            return error.ZipBadFilename;

        if (options.allow_backslashes) {
            std.mem.replaceScalar(u8, filename, '\\', '/');
        } else {
            if (std.mem.indexOfScalar(u8, filename, '\\')) |_|
                return error.ZipFilenameHasBackslash;
        }

        // All entries that end in '/' are directories
        if (filename[filename.len - 1] == '/') {
            if (self.uncompressed_size != 0)
                return error.ZipBadDirectorySize;
            try dest.makePath(filename[0 .. filename.len - 1]);
            return std.hash.Crc32.hash(&.{});
        }

        const out_file = blk: {
            if (std.fs.path.dirname(filename)) |dirname| {
                var parent_dir = try dest.makeOpenPath(dirname, .{});
                defer parent_dir.close();

                const basename = std.fs.path.basename(filename);
                break :blk try parent_dir.createFile(basename, .{ .exclusive = true });
            }
            break :blk try dest.createFile(filename, .{ .exclusive = true });
        };
        defer out_file.close();
        const local_data_file_offset: u64 =
            @as(u64, self.file_offset) +
            @as(u64, @sizeOf(LocalFileHeader)) +
            local_data_header_offset;
        try stream.seekTo(local_data_file_offset);
        var limited_reader = std.io.limitedReader(stream.context.reader(), self.compressed_size);
        const crc = try decompress(
            self.compression_method,
            self.uncompressed_size,
            limited_reader.reader(),
            out_file.writer(),
        );
        if (limited_reader.bytes_left != 0)
            return error.ZipDecompressTruncated;
        return crc;
    }
}