extract

pub fn extract(
    self: Entry,
    stream: *File.Reader,
    options: ExtractOptions,
    filename_buf: []u8,
    dest: std.fs.Dir,
) !void {
    if (filename_buf.len < self.filename_len)
        return error.ZipInsufficientBuffer;
    switch (self.compression_method) {
        .store, .deflate => {},
        else => return error.UnsupportedCompressionMethod,
    }
    const filename = filename_buf[0..self.filename_len];
    {
        try stream.seekTo(self.header_zip_offset + @sizeOf(CentralDirectoryFileHeader));
        try stream.interface.readSliceAll(filename);
    }

    const local_data_header_offset: u64 = local_data_header_offset: {
        const local_header = blk: {
            try stream.seekTo(self.file_offset);
            break :blk try stream.interface.takeStruct(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);
                try stream.interface.readSliceAll(extra);
            }

            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 (options.allow_backslashes) {
        std.mem.replaceScalar(u8, filename, '\\', '/');
    } else {
        if (std.mem.indexOfScalar(u8, filename, '\\')) |_|
            return error.ZipFilenameHasBackslash;
    }

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

    // 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;
    }

    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();
    var out_file_buffer: [1024]u8 = undefined;
    var file_writer = out_file.writer(&out_file_buffer);
    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);

    // TODO limit based on self.compressed_size

    switch (self.compression_method) {
        .store => {
            stream.interface.streamExact64(&file_writer.interface, self.uncompressed_size) catch |err| switch (err) {
                error.ReadFailed => return stream.err.?,
                error.WriteFailed => return file_writer.err.?,
                error.EndOfStream => return error.ZipDecompressTruncated,
            };
        },
        .deflate => {
            var flate_buffer: [flate.max_window_len]u8 = undefined;
            var decompress: flate.Decompress = .init(&stream.interface, .raw, &flate_buffer);
            decompress.reader.streamExact64(&file_writer.interface, self.uncompressed_size) catch |err| switch (err) {
                error.ReadFailed => return stream.err.?,
                error.WriteFailed => return file_writer.err orelse decompress.err.?,
                error.EndOfStream => return error.ZipDecompressTruncated,
            };
        },
        else => return error.UnsupportedCompressionMethod,
    }
    try file_writer.end();
}