const std = @import("std");
const zgz = @import("zgz");

pub fn main(init: std.process.Init) !void {
    const io = init.io;

    var input_file = try std.Io.Dir.cwd().openFile(io, "sample.gz", .{});
    defer input_file.close(io);

    var input_buffer: [256 * 1024]u8 = undefined; // on stack
    var input_reader = input_file.readerStreaming(io, &input_buffer);

    var stdout_file = std.Io.File.stdout();

    var output_buffer: [256 * 1024]u8 = undefined; // on stack
    var output_writer = stdout_file.writer(io, &output_buffer);

    _ = try zgz.decompress(
        &input_reader.interface,
        &output_writer.interface,
        .{
            .allow_concatenated_members = true,
            .max_output_bytes = null,
        },
    );

    try output_writer.interface.flush();
}

const std = @import("std");
const zgz = @import("zgz");

pub fn main(init: std.process.Init) !void {
    const io = init.io;

    var input_file = try std.Io.Dir.cwd().openFile(io, "reads.fastq.gz", .{});
    defer input_file.close(io);

    var input_buffer: [256 * 1024]u8 = undefined; // on stack
    var input_reader = input_file.readerStreaming(io, &input_buffer);

    var gzip: zgz.GzipInput = undefined;
    try gzip.init(
        &input_reader.interface,
        .{
            .allow_concatenated_members = true,
            .max_output_bytes = null,
        },
    );
    defer gzip.deinit();

    var parser_buffer: [800 * 1024]u8 = undefined;  // on stack

    while (true) {
        const result = try gzip.readInto(parser_buffer[0..]);

        // Process parser_buffer[0..result.written]

        if (result.end) break;

        if (result.written == 0) {
            return error.DriverMadeNoProgress;
        }
    }
}

const free = parser.buffer[parser.end..parser.capacity];
const result = try gzip.readInto(free);
parser.end += result.written;
parser.eof = result.end;

var gzip: zgz.GzipInput = undefined;
try gzip.init(&input_reader.interface, .{});
defer gzip.deinit();

var tmp: zgz.GzipInput = undefined;
try tmp.init(&input_reader.interface, .{});

var gzip = tmp;

var wrapper: Wrapper = undefined;

try wrapper.gzip.init(&input_reader.interface, .{});
defer wrapper.gzip.deinit();

pub const StreamOptions = struct {
    allow_concatenated_members: bool = true,
    max_output_bytes: ?usize = null,
};

pub const GzipInputOptions = struct {
    allow_concatenated_members: bool = true,
 max_output_bytes: ?usize = null,
};

_ = try zgz.decompress(reader, writer, .{
    .allow_concatenated_members = false,
});

_ = try zgz.decompress(reader, writer, .{
    .max_output_bytes = 100 * 1024 * 1024,
});

var d: zgz.Decompressor = .{};
try d.initGzip();
defer d.deinit();

var in_pos: usize = 0;
var out_pos: usize = 0;

while (true) {
    const step = try d.decompress(
        compressed[in_pos..],
        output[out_pos..],
    );

    in_pos += step.read;
    out_pos += step.written;

    switch (step.status) {
        .progress, .need_input_or_output => {
            if (step.read == 0 and step.written == 0) {
                return error.DriverMadeNoProgress;
            }
        },
        .end => break,
    }
}

var d: zgz.Decompressor = .{};
try d.initGzip();
defer d.deinit();

var tmp: zgz.Decompressor = .{};
try tmp.initGzip();

var d = tmp;
defer d.deinit();

var wrapper: Wrapper = undefined;

try wrapper.decompressor.initGzip();
defer wrapper.decompressor.deinit();

/// Errors that can occur while driving the zlib-ng inflate state machine.
pub const InflateError = error{
    /// The compressed stream is malformed or not valid for the configured
    /// wrapper format.
    InvalidData,

    /// zlib-ng reported an invalid stream state. This usually means the
    /// decompressor was not initialized, was moved after initialization, 
    /// or the native ABI binding is wrong.
    InvalidState,

    /// zlib-ng could not allocate internal inflate state.
    OutOfMemory,

    /// The input or output slice exceeded zlib-ng's `uint32_t` availability
    /// counter limit.
    SliceTooLarge,

    /// `decompress` was called after the current member reached end-of-stream.
    ///
    /// Call `reset` before feeding another gzip member, or create a new
    /// decompressor. This guard catches accidental post-end reuse instead of
    /// forwarding an invalid state transition into zlib-ng.
    StreamEnded,

    /// zlib-ng returned a code this binding does not recognize.
    UnknownZlibError,
};

/// High-level streaming errors.
pub const StreamError = InflateError || error {
    /// The input ended before zlib-ng reached the gzip stream end marker.
    UnexpectedEnd,

    /// Non-gzip trailing data was present after the first gzip member while
    /// concatenated-member decoding was disabled.
    TrailingData,

    /// The decompressed byte limit was reached before the stream ended.
    OutputLimitExceeded,

    /// The supplied `std.Io.Reader` has no usable buffer.
    ReaderBufferTooSmall,

    /// The supplied `std.Io.Writer` has no usable buffer.
    WriterBufferTooSmall,

    /// The streaming driver observed a successful inflate step that consumed no
    /// input, produced no output, and did not finish the current member.
    ///
    /// Without this guard the driver could spin forever. This usually indicates
    /// a bug in the driver loop, an invalid stream transition, or an unexpected
    /// zlib-ng state-machine result.
    NoProgress,

    /// The underlying `std.Io.Reader` failed.
    ReadFailed,

    /// The underlying `std.Io.Writer` failed.
    WriteFailed,
};