// SPDX-License-Identifier: LGPL-3.0-or-later

#pragma once
#include "internal.h"

#ifdef FUZZING
#define HKVS_SLAB_BLOCK ((size_t)16)
#else
#define HKVS_SLAB_BLOCK ((size_t)4096)
#endif

#define HKVS_REWRITE_THRESHOLD ((size_t)8192)

#define HKVS_SLAB_FREEPTRS ((size_t)8)

#define HKVS_N_SLABS ((uint8_t)40)

#define HKVS_MARK_MAX_SMALL ((uint8_t)249)
#define HKVS_MARK_EXT ((uint8_t)255)
#define HKVS_MARK_SLAB ((uint8_t)254)

#define HKVS_IX_ENTRY ((size_t)16)
#define HKVS_IX_KEY_SIZE ((size_t)16)
#define HKVS_IX_MAX_DISP ((size_t)6)
#define HKVS_IX_SIZE(bits) ((uint64_t)HKVS_IX_ENTRY << (bits))

#define HKVS_PSIZE_HEADER ((size_t)64)
#define HKVS_PARAM_HEADER_MAGIC ((size_t)0)
#define HKVS_PARAM_HEADER_VERSION ((size_t)8)
/*
 * header {
 *     magic: u64,
 *     version: u64,
 *     app_id: u64,
 *     app_ver: u64,
 *     pad: [u64; 4],
 * }
 */

#define HKVS_POFF_SLAB HKVS_PSIZE_HEADER
#define HKVS_PSIZE_SLAB ((size_t)32)
#define HKVS_PARAM_SLAB_FI ((size_t)0)
#define HKVS_PARAM_SLAB_ALLOC ((size_t)8)
#define HKVS_PARAM_SLAB_FREE ((size_t)16)
/*
 * slab {
 *     fi: u64,
 *     alloc_count: u64,
 *     free: u64,
 *     pad: u64,
 * }
 */

#define HKVS_POFF_TABLE ((size_t)(HKVS_POFF_SLAB + HKVS_N_SLABS * HKVS_PSIZE_SLAB))
#define HKVS_PSIZE_TABLE ((size_t)64)
#define HKVS_PARAM_TABLE_ELTSZ ((size_t)32)
#define HKVS_PARAM_TABLE_KEYSZ ((size_t)34)
#define HKVS_PARAM_TABLE_IXBIT ((size_t)35)
#define HKVS_PARAM_TABLE_ID ((size_t)36)
#define HKVS_PARAM_TABLE_IXFI ((size_t)40)
#define HKVS_PARAM_TABLE_IXKEY ((size_t)48)
/* table {
 *     slab;
 *     elt_size: u16,
 *     key_size: u8,
 *     ix_bits: u8,
 *     id: u32,
 *     ix_fi: u64,
 *     ix_key: [u64; 2],
 * }
 */

typedef struct hkvs_slab hkvs_slab;
struct hkvs_slab {
	char *param;
	char *addr;
	size_t map_size;
	size_t elt_size;
};

typedef struct hkvs_table hkvs_table;
struct hkvs_table {
	hkvs_slab slab;
	char *ix;
	size_t ix_size;
};

typedef struct hkvs_extfile hkvs_extfile;
struct hkvs_extfile {
	uint64_t fi;
	char *addr;
	size_t size;
	uint32_t gen;
};

struct hkvs {
	hkvs_io *io;

	char *root_param;
	size_t root_param_size;

	hkvs_table **tables;
	size_t n_tables;
	size_t alloc_tables;

	hkvs_extfile *extfiles;
	size_t n_extfiles;
	size_t alloc_extfiles;
	uint32_t extfile_gen;

	hkvs_slab slabs[HKVS_N_SLABS];
};

HKVS_INTERNAL HKVS_MUSTCHECK int hkvs_extfile_create(hkvs *c, uint64_t *pfi, char **paddr, size_t size, bool pin);

HKVS_INTERNAL HKVS_MUSTCHECK bool hkvs_extfile_find(hkvs *c, uint64_t fi, size_t *pslot);

HKVS_INTERNAL HKVS_MUSTCHECK int hkvs_extfile_open(hkvs *c, uint64_t fi, size_t *pslot, size_t want_size);

HKVS_INTERNAL void hkvs_extfile_close(hkvs *c, size_t slot);

HKVS_INLINE void hkvs_extfile_pin(hkvs *c, hkvs_extfile *f) {
	f->gen = c->extfile_gen;
}

HKVS_INTERNAL HKVS_MUSTCHECK int hkvs_resize_param(hkvs *c);

HKVS_INTERNAL HKVS_MUSTCHECK int hkvs_slab_init(hkvs_slab *s, hkvs_io *io, char *param, size_t elt_size);

HKVS_INLINE void hkvs_slab_destroy(hkvs_slab *s, hkvs_io *io) {
	uint64_t fi = hkvs_read_u64(s->param);
	if(fi) {
		io->close(io, fi, s->addr, s->map_size);
	}
}

HKVS_INTERNAL HKVS_MUSTCHECK int hkvs_slab_alloc(hkvs *c, hkvs_slab *s, size_t *pi);

HKVS_INTERNAL void hkvs_slab_discard(hkvs_slab *s, size_t id);

HKVS_INLINE HKVS_PURE size_t hkvs_slab_size(hkvs_slab *s) {
	uint64_t r = hkvs_read_u64(s->param + HKVS_PARAM_SLAB_ALLOC);
	hkvs_assume(r <= SIZE_MAX / 2);
	return (size_t)r;
}

HKVS_INLINE char *hkvs_slab_mark_at(hkvs_slab *s, size_t i) {
	hkvs_assume(i <= SIZE_MAX / 2);
	hkvs_assume(i < hkvs_slab_size(s));
	size_t j = i & ~(HKVS_SLAB_BLOCK - 1);
	return s->addr + j * s->elt_size + i;
}

HKVS_INLINE char *hkvs_slab_at(hkvs_slab *s, size_t i) {
	hkvs_assume(i <= SIZE_MAX / 2);
	hkvs_assume(i < hkvs_slab_size(s));
	size_t j = i & ~(HKVS_SLAB_BLOCK - 1);
	return s->addr + i * s->elt_size + j + HKVS_SLAB_BLOCK;
}

HKVS_INLINE uint8_t hkvs_slab_mark(hkvs_slab *s, size_t i) {
	return hkvs_read_u8(hkvs_slab_mark_at(s, i));
}

HKVS_INLINE void hkvs_slab_set_mark(hkvs_slab *s, size_t i, uint8_t v) {
	hkvs_write_u8(hkvs_slab_mark_at(s, i), v);
}

HKVS_INTERNAL HKVS_CONST uint8_t hkvs_slab_for_size(size_t data_size);

HKVS_INTERNAL HKVS_MUSTCHECK int hkvs_table_new(hkvs_table **t, hkvs_io *io, char *param);

HKVS_INLINE HKVS_PURE uint32_t hkvs_table__id(hkvs_table *t) {
	return hkvs_read_u32(t->slab.param + HKVS_PARAM_TABLE_ID);
}

HKVS_INLINE HKVS_PURE uint8_t hkvs_table__key_size(hkvs_table *t) {
	return hkvs_read_u8(t->slab.param + HKVS_PARAM_TABLE_KEYSZ);
}

HKVS_INLINE uint8_t hkvs_table__inl_size(hkvs_table *t) {
	size_t r = t->slab.elt_size;
	size_t key_size = hkvs_table__key_size(t);
	hkvs_assume(key_size <= r);
	r -= key_size;
	if(r > 248) r = 248;
	return (uint8_t)r;
}

HKVS_INLINE HKVS_PURE uint8_t hkvs_table__ix_bits(hkvs_table *t) {
	return hkvs_read_u8(t->slab.param + HKVS_PARAM_TABLE_IXBIT);
}

HKVS_INLINE HKVS_PURE const char *hkvs_table__ix_key(hkvs_table *t) {
	return t->slab.param + HKVS_PARAM_TABLE_IXKEY;
}

HKVS_INTERNAL int hkvs_record__value(hkvs *c, hkvs_table *t, size_t id, char *key, size_t key_size, int notfound, char **pvalue, size_t *psize);

HKVS_INLINE void hkvs_table_free(hkvs_table *t, hkvs_io *io) {
	hkvs_slab_destroy(&t->slab, io);
	uint64_t ix_fi = hkvs_read_u64(t->slab.param + HKVS_PARAM_TABLE_IXFI);
	io->close(io, ix_fi, t->ix, t->ix_size);
	free(t);
}

HKVS_INTERNAL HKVS_MUSTCHECK int hkvs_ix_build(hkvs_table *t, hkvs_io *io);
HKVS_INTERNAL HKVS_MUSTCHECK int hkvs_ix_add(hkvs *c, hkvs_table *t, size_t id);
HKVS_INTERNAL void hkvs_ix_remove(hkvs_table *t, size_t id);