// #define PK_UUID_CLOCK CLOCK_REALTIME_ALARM

#define PK_IMPL_STN
#define PK_IMPL_UUID

#include "../pkmacros.h"
#include "../pkuuid.h"

#include "../pktmr.h"

#define PK_IMPL_FUNCINSTR
#include "../pkfuncinstr.h"

#include <stdio.h>

void
print_uuid_v7_breakdown(FILE *f, struct pk_uuid id)
{
	fprintf(f, "-------------------------------------------\n");
	fprintf(f, "field       bits value\n");
	fprintf(f, "-------------------------------------------\n");
	fprintf(f, "unix_ts_ms  48   0x");
	fprintf(f, "%.2x", id.uuid[0]);
	fprintf(f, "%.2x", id.uuid[1]);
	fprintf(f, "%.2x", id.uuid[2]);
	fprintf(f, "%.2x", id.uuid[3]);
	fprintf(f, "%.2x", id.uuid[4]);
	fprintf(f, "%.2x", id.uuid[5]);
	fprintf(f, "\n");

	fprintf(f, "ver          4   0x");
	fprintf(f, "%.x", (id.uuid[6] & 0xF0) >> 4);
	fprintf(f, "\n");

	fprintf(f, "rand_a      12   0x");
	fprintf(f, "%.1x", (id.uuid[6] & 0x0F));
	fprintf(f, "%.2x", id.uuid[7]);
	fprintf(f, "\n");

	fprintf(f, "var          2   0b");
	fprintf(f, "%c", (id.uuid[8] & 0x80) ? '1' : '0');
	fprintf(f, "%c", (id.uuid[8] & 0x40) ? '1' : '0');
	fprintf(f, "\n");

	fprintf(f, "rand_b      62   0b");
	fprintf(f, "%c", (id.uuid[8] & 0x20) ? '1' : '0');
	fprintf(f, "%c", (id.uuid[8] & 0x10) ? '1' : '0');
	fprintf(f, ", 0x");
	fprintf(f, "%.x", (id.uuid[8] & 0x0F));
	fprintf(f, "%.2x", id.uuid[9]);
	fprintf(f, "%.2x", id.uuid[10]);
	fprintf(f, "%.2x", id.uuid[11]);
	fprintf(f, "%.2x", id.uuid[12]);
	fprintf(f, "%.2x", id.uuid[13]);
	fprintf(f, "%.2x", id.uuid[14]);
	fprintf(f, "%.2x", id.uuid[15]);
	fprintf(f, "\n");

	fprintf(f, "-------------------------------------------\n");
}

int
main(int argc, char *argv[])
{
	(void)argc;
	(void)argv;
	pk_uuid_init(time(NULL));

	fprintf(stdout, "\n");
	{
		struct pk_uuid id;
		id = pk_uuid_zed;
		fprintf(stdout, "[%s] zed: " pk_uuid_printf_format "\n", __FILE__, pk_uuid_printf_var(id));
	}

	{
		struct pk_uuid id;
		id = pk_uuid_max;
		fprintf(stdout, "[%s] one: " pk_uuid_printf_format "\n", __FILE__, pk_uuid_printf_var(id));
	}

	{
		struct pk_uuid id1, id2;
		bool equals;
		id1 = pk_uuid_zed;
		id2 = pk_uuid_zed;
		equals = pk_uuid_equals(id1, id2);
		fprintf(stdout, "[%s] equals (zed, zed): %s\n", __FILE__, equals ? "true" : "false");
		if (equals != true) exit(1);
		id1 = pk_uuid_new_v7();
		id2 = pk_uuid_new_v7();
		equals = pk_uuid_equals(id1, id2);
		fprintf(stdout, "[%s] equals (rand, rand): %s\n", __FILE__, equals ? "true" : "false");
		if (equals != false) exit(1);
	}

	FILE *f = fopen("perf.json", "w");
	pk_funcinstr_init();
	{
		const int count = 4;
		struct pk_uuid ids[count];

		for (int i = 0; i < count; ++i) {
			ids[i] = pk_uuid_new_v7();
		}
		for (int i = 0; i < count; ++i) {
			fprintf(stdout, "[%s] new: " pk_uuid_printf_format "\n", __FILE__, pk_uuid_printf_var(ids[i]));
		}

		for (int i = 0; i < count; ++i) {
			fprintf(stdout, "\n");
			print_uuid_v7_breakdown(stdout, ids[i]);
			fprintf(stdout, "[%s] new: " pk_uuid_printf_format "\n", __FILE__, pk_uuid_printf_var(ids[i]));
		}
		fprintf(stdout, "\n");
	}
	pk_funcinstr_write(f);
	pk_funcinstr_teardown();
	fflush(f);
	fclose(f);

	// test parse
	pk_funcinstr_init();
	{
		bool res;
		unsigned char i;
		struct pk_uuid idm;
		struct pk_uuid idz;
		struct pk_uuid id;
		struct pk_uuid id_expected = { .uuid = { 0x67, 0xe5, 0x98, 0x5c, 0x82, 0xb7, 0x72, 0x69, 0x94, 0xda, 0x81, 0x9c, 0x18, 0xa7, 0xec, 0xe8 } };
		const char * s_idm = "ffffffff-ffff-ffff-ffff-ffffffffffff";
		const char * s_idz = "00000000-0000-0000-0000-000000000000";
		const char * s_id  = "67e5985c-82b7-7269-94da-819c18a7ece8";

		fprintf(stdout, "[%s] test parse.\n", __FILE__);
		res = pk_uuid_parse(s_idm, &idm);
		fprintf(stdout, "[%s] expected: " pk_uuid_printf_format "\n", __FILE__, pk_uuid_printf_var(pk_uuid_max));
		fprintf(stdout, "[%s] parsed  : " pk_uuid_printf_format "\n", __FILE__, pk_uuid_printf_var(idm));
		if (res == false) exit(1);

		res = pk_uuid_parse(s_idz, &idz);
		fprintf(stdout, "[%s] expected: " pk_uuid_printf_format "\n", __FILE__, pk_uuid_printf_var(pk_uuid_zed));
		fprintf(stdout, "[%s] parsed  : " pk_uuid_printf_format "\n", __FILE__, pk_uuid_printf_var(idz));
		if (res == false) exit(1);

		res = pk_uuid_parse(s_id, &id);
		fprintf(stdout, "[%s] expected: " pk_uuid_printf_format "\n", __FILE__, pk_uuid_printf_var(id_expected));
		fprintf(stdout, "[%s] parsed  : " pk_uuid_printf_format "\n", __FILE__, pk_uuid_printf_var(id));
		if (res == false) exit(1);

		for (i = 0; i < 16; ++i) {
			if (idm.uuid[i] != 0xFF) exit(1);
			if (idz.uuid[i] != 0x00) exit(1);
			if (id.uuid[i] != id_expected.uuid[i]) exit(1);
		}
		fprintf(stdout, "\n");
	}
	pk_funcinstr_teardown();

	{
		double ms;
		const int count = 1000;
		struct pk_uuid ids[count];
		struct pk_tmr tmr;
		pk_tmr_start(tmr);
		for (int i = 0; i < count; ++i) {
			ids[i] = pk_uuid_new_v7();
		}
		pk_tmr_stop(tmr);
		fprintf(stdout, "generated %i ids...\n", count);
		ms = pk_tmr_duration_dbl_mili(tmr);
		fprintf(stdout, "elapsed time      : %f ms\n", ms);
		fprintf(stdout, "elapsed time (avg): %f ms\n", ms / (double)count);
		fprintf(stdout, pk_uuid_printf_format "\n", pk_uuid_printf_var(ids[0]));
		fprintf(stdout, pk_uuid_printf_format "\n", pk_uuid_printf_var(ids[99]));
	}

	// not really a test, just checking time
	/* 2025-03-19 JCB - Disabled because we added a macro to define the clock
	 *  instead of passing it as a parameter.
	{
		double ms;
		const int count = 1000;
		struct pk_uuid ids[count];
		struct pk_tmr tmr;
		pk_tmr_start(tmr);
		for (int i = 0; i < count; ++i) {
			ids[i] = pk_uuid_new_v7(CLOCK_REALTIME);
		}
		pk_tmr_stop(tmr);
		fprintf(stdout, "generated %i ids using CLOCK_REALTIME...\n", count);
		ms = pk_tmr_duration_dbl_mili(tmr);
		fprintf(stdout, "elapsed time      : %f ms\n", ms);
		fprintf(stdout, "elapsed time (avg): %f ms\n", ms / (double)count);
		fprintf(stdout, pk_uuid_printf_format "\n", pk_uuid_printf_var(ids[0]));
		fprintf(stdout, pk_uuid_printf_format "\n", pk_uuid_printf_var(ids[99]));

		pk_tmr_start(tmr);
		for (int i = 0; i < count; ++i) {
			ids[i] = pk_uuid_new_v7(CLOCK_REALTIME_COARSE);
		}
		pk_tmr_stop(tmr);
		fprintf(stdout, "generated %i ids using CLOCK_REALTIME_COARSE...\n", count);
		ms = pk_tmr_duration_dbl_mili(tmr);
		fprintf(stdout, "elapsed time      : %f ms\n", ms);
		fprintf(stdout, "elapsed time (avg): %f ms\n", ms / (double)count);
		fprintf(stdout, pk_uuid_printf_format "\n", pk_uuid_printf_var(ids[0]));
		fprintf(stdout, pk_uuid_printf_format "\n", pk_uuid_printf_var(ids[99]));

		pk_tmr_start(tmr);
		for (int i = 0; i < count; ++i) {
			ids[i] = pk_uuid_new_v7(CLOCK_TAI);
		}
		pk_tmr_stop(tmr);
		fprintf(stdout, "generated %i ids using CLOCK_TAI...\n", count);
		ms = pk_tmr_duration_dbl_mili(tmr);
		fprintf(stdout, "elapsed time      : %f ms\n", ms);
		fprintf(stdout, "elapsed time (avg): %f ms\n", ms / (double)count);
		fprintf(stdout, pk_uuid_printf_format "\n", pk_uuid_printf_var(ids[0]));
		fprintf(stdout, pk_uuid_printf_format "\n", pk_uuid_printf_var(ids[99]));
	}
	*/

	pk_uuid_teardown();

	return 0;
}