#ifndef LILY_TEST_H
#define LILY_TEST_H

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <setjmp.h>

#define STR_IMP(x) #x
#define STR(x) STR_IMP(x)
/* define SOURCE_PATH_SIZE to strip away the
   leading parts of the full compilation path */
#ifndef SOURCE_PATH_SIZE
#define LILY_LOCATION (__FILE__ ":" STR(__LINE__))
#else
#define LILY_LOCATION ((__FILE__ ":" STR(__LINE__)) + SOURCE_PATH_SIZE)
#endif

struct lily_globals_t {
   jmp_buf env;
   size_t error_msg_len;
   char *error_msg;
   const char *error_location;
};

extern struct lily_globals_t _lily_globals;
void lily_init();


/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 * assertions
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

void lily_assert_msg(bool statement, const char *location,
		     const char *format_string, ...);

#define lily_assert_true(statement) _lily_assert_true(#statement, statement, LILY_LOCATION)
void _lily_assert_true(const char *statement, bool value, const char *location);


#define lily_assert_false(statement) _lily_assert_false(#statement, statement, LILY_LOCATION)
void _lily_assert_false(const char *statement, bool value, const char *location);


#define lily_assert_not_null(ptr) _lily_assert_not_null(#ptr, ptr, LILY_LOCATION)
void _lily_assert_not_null(const char *name, void *ptr, const char *location);


#define lily_assert_null(ptr) _lily_assert_null(#ptr, ptr, LILY_LOCATION)
void _lily_assert_null(const char *name, void *ptr, const char *location);


#define lily_assert_ptr_equal(a, b) _lily_assert_ptr_equal(#a, #b, a, b, LILY_LOCATION)
void _lily_assert_ptr_equal(const char *name_a, const char *name_b,
			    void *a, void *b, const char *location);


#define lily_assert_ptr_not_equal(a, b) _lily_assert_ptr_not_equal(#a, #b, a, b, LILY_LOCATION)
void _lily_assert_ptr_not_equal(const char *name_a, const char *name_b,
				void *a, void *b, const char *location);


#define lily_assert_int_equal(a, b) _lily_assert_int_equal(#a, #b, a, b, LILY_LOCATION)
void _lily_assert_int_equal(const char *name_a, const char *name_b,
			    intmax_t a, intmax_t b, const char *location);


#define lily_assert_int_not_equal(a, b) _lily_assert_int_not_equal(#a, #b, a, b, LILY_LOCATION)
void _lily_assert_int_not_equal(const char *name_a, const char *name_b,
				intmax_t a, intmax_t b, const char *location);


#define lily_assert_float_equal(a, b, epsilon)				\
   _lily_assert_float_equal(#a, #b, a, b, epsilon, LILY_LOCATION)
void _lily_assert_float_equal(const char *name_a, const char *name_b,
			      double a, double b, double epsilon, const char *location);


#define lily_assert_float_not_equal(a, b, epsilon)	\
   _lily_assert_float_not_equal(#a, #b, a, b, epsilon, LILY_LOCATION)
void _lily_assert_float_not_equal(const char *name_a, const char *name_b,
				  double a, double b, double epsilon, const char *location);


#define lily_assert_string_equal(a, b) _lily_assert_string_equal(#a, #b, a, b, LILY_LOCATION)
void _lily_assert_string_equal(const char *name_a, const char *name_b,
			       char *a, char *b, const char *location);


#define lily_assert_string_not_equal(a, b) _lily_assert_string_not_equal(#a, #b, a, b, LILY_LOCATION)
void _lily_assert_string_not_equal(const char *name_a, const char *name_b,
				   char *a, char *b, const char *location);


#define lily_assert_memory_equal(a, b, size)			\
   _lily_assert_memory_equal(#a, #b, a, b, size, LILY_LOCATION)
void _lily_assert_memory_equal(const char *name_a, const char *name_b,
			       void *a, void *b, size_t size, const char *location);


#define lily_assert_memory_not_equal(a, b, size)	\
   _lily_assert_memory_not_equal(#a, #b, a, b, size, LILY_LOCATION)
void _lily_assert_memory_not_equal(const char *name_a, const char *name_b,
				   void *a, void *b, size_t size, const char *location);


/* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 * mocks
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

typedef struct lily_queue_t {
   size_t buf_size;
   uint8_t *buf;
   uint8_t *front, *back;
} lily_queue_t;


lily_queue_t* lily_queue_create();
void lily_queue_destroy(lily_queue_t *q);

#define lily_enqueue(q, type, value)		\
   do {						\
   type _var = value;					\
   _lily_enqueue(q, sizeof(type), (uint8_t*)(&_var));			\
   } while(0)
void _lily_enqueue(lily_queue_t *q, size_t size, uint8_t *data);


#define lily_dequeue(q, type, ptr)		\
   _lily_dequeue(q, sizeof(type), (uint8_t*) ptr)
void _lily_dequeue(lily_queue_t *q, size_t size, uint8_t *ptr);

#endif