module compress

#flag -I @VEXEROOT/thirdparty/zip
#define MINIZ_NO_ZLIB_COMPATIBLE_NAMES
#include "miniz.h"

pub const max_size = u64(1 << 31)

fn C.tdefl_compress_mem_to_heap(source_buf voidptr, source_buf_len usize, out_len &usize, flags i32) voidptr
fn C.tinfl_decompress_mem_to_heap(source_buf voidptr, source_buf_len usize, out_len &usize, flags i32) voidptr

// compresses an array of bytes based on providing flags and returns the compressed bytes in a new array
// NB: this is a low level api, a high level implementation like zlib/gzip should be preferred
@[manualfree]
pub fn compress(data []u8, flags int) ![]u8 {
    if u64(data.len) > max_size {
        return error('data too large (${data.len} > ${max_size})')
    }
    mut out_len := usize(0)

    address := C.tdefl_compress_mem_to_heap(data.data, data.len, &out_len, flags)
    if address == 0 {
        return error('compression failed')
    }
    if u64(out_len) > max_size {
        return error('compressed data is too large (${out_len} > ${max_size})')
    }
    unsafe {
        ret := address.vbytes(int(out_len)).clone()
        C.free(address)
        return ret
    }
}

// decompresses an array of bytes based on providing flags and returns the decompressed bytes in a new array
// NB: this is a low level api, a high level implementation like zlib/gzip should be preferred
@[manualfree]
pub fn decompress(data []u8, flags int) ![]u8 {
    mut out_len := usize(0)

    address := C.tinfl_decompress_mem_to_heap(data.data, data.len, &out_len, flags)
    if address == 0 {
        return error('decompression failed')
    }
    if u64(out_len) > max_size {
        return error('decompressed data is too large (${out_len} > ${max_size})')
    }

    unsafe {
        ret := address.vbytes(int(out_len)).clone()
        C.free(address)
        return ret
    }
}

// ChunkCallback is used to receive decompressed chunks of maximum 32768 bytes.
// After processing the chunk this function should return the chunk's length to indicate
// the decompressor to send more chunks, otherwise the decompression stops.
// The userdata parameter comes from the call to decompress_with_callback/4, and can be used
// to pass arbitrary data, without having to create a closure.
pub type ChunkCallback = fn (chunk []u8, userdata voidptr) int

// decompress_with_callback decompresses an array of bytes, based on the provided flags, and a V fn callback to receive decompressed chunks, of at most 32 kilobytes each.
// It returns the total decompressed length, or a decompression error.
// NB: this is a low level api, a high level implementation like zlib/gzip should be preferred.
pub fn decompress_with_callback(data []u8, cb ChunkCallback, userdata voidptr, flags int) !u64 {
    cbdata := DecompressionCallBackData{
        data:     data.data
        size:     usize(data.len)
        cb:       cb
        userdata: userdata
    }
    status := C.tinfl_decompress_mem_to_callback(cbdata.data, &cbdata.size,
        c_cb_for_decompress_mem, &cbdata, flags)
    if status == 0 {
        return error('decompression error')
    }
    return cbdata.decompressed_size
}

struct DecompressionCallBackData {
mut:
    data              voidptr
    size              usize
    decompressed_size u64
    userdata          voidptr
    cb                ChunkCallback = unsafe { nil }
}

fn c_cb_for_decompress_mem(buf &char, len int, pdcbd voidptr) int {
    mut cbdata := unsafe { &DecompressionCallBackData(pdcbd) }
    if cbdata.cb(unsafe { voidptr(buf).vbytes(len) }, cbdata.userdata) == len {
        cbdata.decompressed_size += u64(len)
        return 1 // continue decompressing
    }
    return 0 // stop decompressing
}

type DecompressCallback = fn (const_buffer voidptr, len int, userdata voidptr) int

fn C.tinfl_decompress_mem_to_callback(const_input_buffer voidptr, psize &usize, put_buf_cb DecompressCallback, userdata voidptr, flags i32) i32