#include <stdio.h>
#include <stddef.h>
#include <stdint.h>
#include <setjmp.h>
#include <string.h>
#include <stdarg.h>
#include <cmocka.h>

enum defenum { //#
	Defvalue = -1,
	Value0, //#
	Value1, //#
	Value2, //#
};

struct innerdefaults { //# decoder encoder
	int x;     //#1 default=-666 signed
	char c[8]; //#2 default='"lol"'
	char s[8]; //# default='"ftw"'
	int y;     //# default=13
};

struct defaults { //# decoder encoder
	int i;                            //#1 default=-1
	uint32_t u;                       //#2 default=1
	uint64_t u64;                     //#3 default=0xfffffffffffffff1
	enum defenum e;                   //#4 default=Defvalue
	char s[6];                        //#5
	uint8_t b[2];                     //#6
	struct innerdefaults inner;       //#7
	int num_repeated;
	struct innerdefaults repeated[4]; //#8 num_at=^
	int16_t i16;                      //#9 default=-32768 signed
	int8_t i8;                        //#10 default=-128 signed
	struct innerdefaults *inptr;      //#11
	int *iptr;                        //#12
	uint8_t buffer[64]; //# buffer=here

	uint8_t b0[2];
	char s0[2];
	int x0;
	char *ptr0;
};

static struct innerdefaults inptr;

#include "test_defaults.pb.h"

void
test_defaults_reset_pretty(void **state)
{
	struct defaults d;
	char buf[128];

	(void)state;
	memset(&d, 0xff, sizeof(d));
	d.inptr = &inptr;
	memset(&inptr, 0xff, sizeof(inptr));
	d.b0[0] = 1;
	d.b0[1] = 2;
	d.s0[0] = 'a';
	d.s0[1] = 'b';
	d.x0 = 13;
	d.ptr0 = buf;

	pb_reset_defaults(&d);
	assert_non_null(pb_seprint_defaults(&d, buf, buf+sizeof(buf), 0, 0));
	assert_string_equal(
		buf,
		"{}"
	);
	assert_int_equal(d.b0[0], 1);
	assert_int_equal(d.b0[1], 2);
	assert_int_equal(d.s0[0], 'a');
	assert_int_equal(d.s0[1], 'b');
	assert_int_equal(d.x0, 13);
	assert_ptr_equal(d.ptr0, buf);
}

void
test_defaults_pretty(void **state)
{
	struct defaults d;
	char buf[256];

	(void)state;
	memset(&d, 0, sizeof(d));
	d.inptr = &inptr;
	memset(&inptr, 0, sizeof(inptr));
	assert_non_null(pb_seprint_defaults(&d, buf, buf+sizeof(buf), 0, 1));
	assert_string_equal(
		buf,
		"{\n"
		" i = 0, // #1\n"
		" u = 0, // #2\n"
		" u64 = 0, // #3\n"
		" e = 0 (Value0), // #4\n"
		" inner = {\n"
		"  x = 0, // #1\n"
		"  c = \"\", // #2\n"
		"  s = \"\",\n"
		"  y = 0,\n"
		" }, // #7\n"
		" i16 = 0, // #9\n"
		" i8 = 0, // #10\n"
		" inptr = {\n"
		"  x = 0, // #1\n"
		"  c = \"\", // #2\n"
		"  s = \"\",\n"
		"  y = 0,\n"
		" }, // #11\n"
		"}"
	);
}

void
test_defaults_decode_pretty(void **state)
{
	// i:-1, u:1, u64:0xfffffffffffffff1, inner:{x:-666, c:"lol"}, i16:-32768, i8:-128, sptr:{x:-666, c:"lol"}, iptr:17
	const uint8_t raw[] = {
		0x08, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x10, 0x01, 0x18, 0xf1, 0xff,
		0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x3a, 0x08, 0x08, 0xb3, 0x0a, 0x12, 0x03, 0x6c,
		0x6f, 0x6c, 0x48, 0xff, 0xff, 0x03, 0x50, 0xff, 0x01, 0x5a, 0x08, 0x08, 0xb3, 0x0a, 0x12, 0x03,
		0x6c, 0x6f, 0x6c, 0x60, 0x11,
	};
	struct defaults d;
	char buf[256];

	(void)state;
	strncpy(d.inner.s, "hello", sizeof(d.inner.s));
	d.inner.y = 666;
	d.b0[0] = 1;
	d.b0[1] = 2;
	d.s0[0] = 'a';
	d.s0[1] = 'b';
	d.x0 = 13;
	d.ptr0 = buf;
	d.inptr = &inptr;
	strncpy(inptr.s, "what", sizeof(inptr.s));
	inptr.y = 555;
	d.iptr = NULL; // ignore the value
	assert_ptr_equal(pb_decode_defaults(&d, raw, raw+sizeof(raw)), raw+sizeof(raw));
	assert_non_null(pb_seprint_defaults(&d, buf, buf+sizeof(buf), 2, 3));
	assert_string_equal(
		buf,
		"{\n"
		"     inner = {\n"
		"        s = \"hello\",\n"
		"        y = 666,\n"
		"     }, // #7\n"
		"     inptr = {\n"
		"        s = \"what\",\n"
		"        y = 555,\n"
		"     }, // #11\n"
		"  }"
	);
	assert_int_equal(d.i, -1);
	assert_int_equal(d.u, 1);
	assert_int_equal(d.u64, 0xfffffffffffffff1LL);
	assert_int_equal(d.e, Defvalue);
	assert_int_equal(d.s[0], 0);
	assert_int_equal(d.b[0], 0);
	assert_int_equal(d.b[1], 0);
	assert_int_equal(d.inner.x, -666);
	assert_string_equal(d.inner.c, "lol");
	assert_string_equal(d.inner.s, "hello");
	assert_int_equal(d.inner.y, 666);
	assert_int_equal(d.num_repeated, 0);
	assert_int_equal(d.b0[0], 1);
	assert_int_equal(d.b0[1], 2);
	assert_int_equal(d.s0[0], 'a');
	assert_int_equal(d.s0[1], 'b');
	assert_int_equal(d.x0, 13);
	assert_ptr_equal(d.ptr0, buf);
}