#define _POSIX_C_SOURCE 200809L
#include "ts.h"
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

typedef int (*ts_func_t)(fp_t * const *, uint_t, fp_t const * const *, uint_t, uint_t, ts_constant_t const *);

typedef struct {
    ts_func_t func;
    uint_t xn;
    uint_t yn;
} fuzz_entry_t;

#include "fuzz_table_generated.c"

static const uint_t _fuzz_n = _fuzz_generated_n;
static const fuzz_entry_t *_fuzz_table = _fuzz_table_generated;

int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
{
    if (size < 2)
        return 0;

    uint_t func_idx = data[0];
    uint_t config = data[1];

    uint_t n = 4;
    if (size > 2)
        n = (uint_t)(data[2] + 4);
    if (n > 256)
        n = 256;

    fp_t input[256];
    fp_t output[256];
    fp_t output2[256];
    fp_t output3[256];

    size_t offset = 3;
    for (uint_t i = 0; i < n && offset + 8 <= size; i++, offset += 8)
    {
        memcpy(&input[i], data + offset, sizeof(fp_t));
    }
    for (uint_t i = (offset - 3) / 8; i < n; i++)
        input[i] = 0;

    fp_t *x_arrays[5] = {input, input, input, input, input};
    fp_t *y_arrays[3] = {output, output2, output3};

    uint_t period = 5;
    if (config > 0)
        period = config;
    if (period < 1)
        period = 1;
    if (period > n)
        period = n;

    uint_t idx = func_idx % _fuzz_n;
    fuzz_entry_t entry = _fuzz_table[idx];

    uint_t xn = entry.xn;
    uint_t yn = entry.yn;
    if (xn > 5) xn = 5;
    if (yn > 3) yn = 3;

    ts_constant_t c;
    memset(&c, 0, sizeof(c));
    memcpy(c.data, &period, sizeof(period));
    (void)entry.func(y_arrays, yn, (fp_t const * const *)x_arrays, xn, n, &c);

    return 0;
}