#ifndef VEC_H
#define VEC_H

#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

struct vec {
	size_t n;
	size_t s;
	size_t ns;
	void *buf;
};

#define foreach_vec(iter, v) \
	for (size_t iter = 0; iter < vec_len(&v); ++iter)

#define vect_at(type, v, i) \
	*(type *)vec_at(&v, i)

#define vect_append(type, v, e) \
	vec_append(&v, (type *)(e))

#define vect_back(type, v) \
	*(type *)vec_back(&v)

#define vect_pop(type, v) \
	*(type *)vec_pop(&v)

#define vec_uninit(v) \
	(v.buf == NULL)

static inline struct vec vec_create(size_t ns)
{
	return (struct vec) {
		       .n = 0,
		       .s = 1,
		       .ns = ns,
		       .buf = malloc(ns),
	};
}

static inline size_t vec_len(struct vec *v)
{
	return v->n;
}

static inline void *vec_at(struct vec *v, size_t i)
{
	assert(i < v->n && "out of vector bounds");
	return v->buf + i * v->ns;
}

static inline void *vec_back(struct vec *v)
{
	assert(v->n);
	return v->buf + (v->n - 1) * v->ns;
}

static inline void *vec_pop(struct vec *v)
{
	assert(v->n && "attempting to pop empty vector");
	v->n--;
	return v->buf + v->n * v->ns;
}

static inline void vec_append(struct vec *v, void *n)
{
	v->n++;
	if (v->n >= v->s) {
		v->s *= 2;
		v->buf = realloc(v->buf, v->s * v->ns);
	}

	void *p = vec_at(v, v->n - 1);
	memcpy(p, n, v->ns);
}

static inline void vec_reset(struct vec *v)
{
	v->n = 0;
}

static inline void vec_destroy(struct vec *v) {
	free(v->buf);
}

typedef int (*vec_comp_t)(void *a, void *b);
static inline void vec_sort(struct vec *v, vec_comp_t comp)
{
	qsort(v->buf, v->n, v->ns, (__compar_fn_t)comp);
}

static inline void vec_reserve(struct vec *v, size_t n)
{
	if (v->n >= n)
		return;

	v->n = n;
	v->s = n;
	v->buf = realloc(v->buf, v->s * v->ns);
}

#endif /* VEC_H */