// SPDX-License-Identifier: GPL-2.0-only
/* Copyright(c) 2026 Intel Corporation */
#include <linux/errno.h>
#include <linux/printk.h>
#include <linux/string.h>
#include <linux/unaligned.h>
#include <linux/zstd.h>

#include "qat_comp_zstd_utils.h"

#define ML_BITS		4
#define ML_MASK		((1U << ML_BITS) - 1)
#define RUN_BITS	(8 - ML_BITS)
#define RUN_MASK	((1U << RUN_BITS) - 1)
#define LZ4S_MINMATCH	2

/*
 * ZSTD blocks can decompress to at most min(windowSize, 128KB) bytes.
 * Insert explicit block delimiters to keep blocks within this limit.
 */
#define QAT_ZSTD_BLOCK_MAX	ZSTD_BLOCKSIZE_MAX

static int emit_delimiter(ZSTD_Sequence *out_seqs, size_t *seqs_idx,
			  size_t out_seqs_capacity, unsigned int lz4s_buff_size)
{
	if (*seqs_idx >= out_seqs_capacity - 1) {
		pr_debug("QAT ZSTD: sequence overflow (seqs_idx:%zu, capacity:%zu, lz4s_size:%u)\n",
			 *seqs_idx, out_seqs_capacity, lz4s_buff_size);
		return -EOVERFLOW;
	}

	out_seqs[*seqs_idx].offset = 0;
	out_seqs[*seqs_idx].litLength = 0;
	out_seqs[*seqs_idx].matchLength = 0;
	(*seqs_idx)++;

	return 0;
}

int qat_alg_dec_lz4s(ZSTD_Sequence *out_seqs, size_t out_seqs_capacity,
		     unsigned char *lz4s_buff, unsigned int lz4s_buff_size,
		     unsigned char *literals, unsigned int *lit_len)
{
	unsigned char *end_ip = lz4s_buff + lz4s_buff_size;
	unsigned char *start, *dest, *dest_end;
	unsigned int hist_literal_len = 0;
	unsigned char *ip = lz4s_buff;
	size_t block_decomp_size = 0;
	size_t seqs_idx = 0;
	int ret;

	*lit_len = 0;

	if (!lz4s_buff_size)
		return 0;

	while (ip < end_ip) {
		size_t literal_len = 0, match_len = 0;
		const unsigned int token = *ip++;
		size_t length = 0;
		size_t offset = 0;

		/* Get literal length */
		length = token >> ML_BITS;
		if (length == RUN_MASK) {
			unsigned int s;

			do {
				s = *ip++;
				length += s;
			} while (s == 255);
		}

		literal_len = length;

		start = ip;
		dest = literals;
		dest_end = literals + length;

		do {
			memcpy(dest, start, QAT_ZSTD_LIT_COPY_LEN);
			dest += QAT_ZSTD_LIT_COPY_LEN;
			start += QAT_ZSTD_LIT_COPY_LEN;
		} while (dest < dest_end);

		literals += length;
		*lit_len += length;

		ip += length;
		if (ip == end_ip) {
			literal_len += hist_literal_len;
			/*
			 * If adding trailing literals would overflow the
			 * current block, close it first.
			 */
			if (block_decomp_size + literal_len > QAT_ZSTD_BLOCK_MAX) {
				ret = emit_delimiter(out_seqs, &seqs_idx,
						     out_seqs_capacity,
						     lz4s_buff_size);
				if (ret)
					return ret;
			}
			out_seqs[seqs_idx].litLength = literal_len;
			out_seqs[seqs_idx].offset = offset;
			out_seqs[seqs_idx].matchLength = match_len;
			break;
		}

		offset = get_unaligned_le16(ip);
		ip += 2;

		length = token & ML_MASK;
		if (length == ML_MASK) {
			unsigned int s;

			do {
				s = *ip++;
				length += s;
			} while (s == 255);
		}
		if (length != 0) {
			length += LZ4S_MINMATCH;
			match_len = (unsigned short)length;
			literal_len += hist_literal_len;

			/*
			 * If this sequence would push the current block past
			 * the ZSTD maximum, close the block first.
			 */
			if (block_decomp_size + literal_len + match_len > QAT_ZSTD_BLOCK_MAX) {
				ret = emit_delimiter(out_seqs, &seqs_idx,
						     out_seqs_capacity,
						     lz4s_buff_size);
				if (ret)
					return ret;

				block_decomp_size = 0;
			}

			out_seqs[seqs_idx].offset = offset;
			out_seqs[seqs_idx].litLength = literal_len;
			out_seqs[seqs_idx].matchLength = match_len;
			hist_literal_len = 0;
			seqs_idx++;
			if (seqs_idx >= out_seqs_capacity - 1) {
				pr_debug("QAT ZSTD: sequence overflow (seqs_idx:%zu, capacity:%zu, lz4s_size:%u)\n",
					 seqs_idx, out_seqs_capacity, lz4s_buff_size);
				return -EOVERFLOW;
			}

			block_decomp_size += literal_len + match_len;
		} else {
			if (literal_len > 0) {
				/*
				 * When match length is 0, the literal length needs
				 * to be temporarily stored and processed together
				 * with the next data block.
				 */
				hist_literal_len += literal_len;
			}
		}
	}

	return seqs_idx + 1;
}