// SPDX-License-Identifier: GPL-2.0

#include <string.h>

#include "util/compress.h"
#include "util/debug.h"

int zstd_init(struct zstd_data *data, int level)
{
        data->comp_level = level;
        data->dstream = NULL;
        data->cstream = NULL;
        return 0;
}

int zstd_fini(struct zstd_data *data)
{
        if (data->dstream) {
                ZSTD_freeDStream(data->dstream);
                data->dstream = NULL;
        }

        if (data->cstream) {
                ZSTD_freeCStream(data->cstream);
                data->cstream = NULL;
        }

        return 0;
}

ssize_t zstd_compress_stream_to_records(struct zstd_data *data, void *dst, size_t dst_size,
                                       void *src, size_t src_size, size_t max_record_size,
                                       size_t process_header(void *record, size_t increment))
{
        size_t ret, size, compressed = 0;
        ZSTD_inBuffer input = { src, src_size, 0 };
        ZSTD_outBuffer output;
        void *record;

        if (!data->cstream) {
                data->cstream = ZSTD_createCStream();
                if (data->cstream == NULL) {
                        pr_err("Couldn't create compression stream.\n");
                        return -1;
                }

                ret = ZSTD_initCStream(data->cstream, data->comp_level);
                if (ZSTD_isError(ret)) {
                        pr_err("Failed to initialize compression stream: %s\n",
                                ZSTD_getErrorName(ret));
                        return -1;
                }
        }

        while (input.pos < input.size) {
                record = dst;
                size = process_header(record, 0);
                compressed += size;
                dst += size;
                dst_size -= size;
                output = (ZSTD_outBuffer){ dst, (dst_size > max_record_size) ?
                                                max_record_size : dst_size, 0 };
                ret = ZSTD_compressStream(data->cstream, &output, &input);
                ZSTD_flushStream(data->cstream, &output);
                if (ZSTD_isError(ret)) {
                        pr_err("failed to compress %ld bytes: %s\n",
                                (long)src_size, ZSTD_getErrorName(ret));
                        memcpy(dst, src, src_size);
                        return src_size;
                }
                size = output.pos;
                size = process_header(record, size);
                compressed += size;
                dst += size;
                dst_size -= size;
        }

        return compressed;
}

size_t zstd_decompress_stream(struct zstd_data *data, void *src, size_t src_size,
                              void *dst, size_t dst_size)
{
        size_t ret;
        ZSTD_inBuffer input = { src, src_size, 0 };
        ZSTD_outBuffer output = { dst, dst_size, 0 };

        if (!data->dstream) {
                data->dstream = ZSTD_createDStream();
                if (data->dstream == NULL) {
                        pr_err("Couldn't create decompression stream.\n");
                        return 0;
                }

                ret = ZSTD_initDStream(data->dstream);
                if (ZSTD_isError(ret)) {
                        pr_err("Failed to initialize decompression stream: %s\n",
                                ZSTD_getErrorName(ret));
                        return 0;
                }
        }
        while (input.pos < input.size) {
                ret = ZSTD_decompressStream(data->dstream, &output, &input);
                if (ZSTD_isError(ret)) {
                        pr_err("failed to decompress (B): %zd -> %zd, dst_size %zd : %s\n",
                               src_size, output.size, dst_size, ZSTD_getErrorName(ret));
                        break;
                }
                output.dst  = dst + output.pos;
                output.size = dst_size - output.pos;
        }

        return output.pos;
}