#include "./pke-test-serialization.h"

#include "asset-manager.hpp"
#include "font.hpp"
#include "game-settings.hpp"
#include "camera.hpp"
#include "ecs.hpp"
#include "level.hpp"
#include "physics.hpp"
#include "pk.h"
#include "pke-test-stubs.h"
#include "pke-test-types.h"
#include "scene.hpp"
#include "serialization-component.hpp"
#include "serialization.hpp"
#include "static-ui.hpp"
#include "thread-pool.hpp"

#include <cstring>
#include <sstream>

static pk_membucket *bkt = nullptr;
const char *test_level_name = "srlztn_test_level";
pke_level *test_level = nullptr;
FontType *ft;

#define FAKE_UUID_GEN(oct) { .uuid = { oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct,oct } }

const pk_uuid uuid_n[] = {
	FAKE_UUID_GEN(0x00),
	FAKE_UUID_GEN(0x01),
	FAKE_UUID_GEN(0x02),
	FAKE_UUID_GEN(0x03),
	FAKE_UUID_GEN(0x04),
	FAKE_UUID_GEN(0x05),
	FAKE_UUID_GEN(0x06),
	FAKE_UUID_GEN(0x07),
	FAKE_UUID_GEN(0x08),
	FAKE_UUID_GEN(0x09),
	FAKE_UUID_GEN(0x0a),
	FAKE_UUID_GEN(0x0b),
	FAKE_UUID_GEN(0x0c),
	FAKE_UUID_GEN(0x0d),
	FAKE_UUID_GEN(0x0e),
	FAKE_UUID_GEN(0x0f),
};
// const pk_uuid uuid_17 = FAKE_UUID_GEN(0x11);
// const pk_uuid uuid_34 = FAKE_UUID_GEN(0x22);

void pke_test_serialization_spinup() {
	pke_test_stub_init_vulkan();
	// pk_funcinstr_init();
	bkt = pk_mem_bucket_create("pke_test_serialization", PK_MEM_DEFAULT_BUCKET_SIZE, PK_MEMBUCKET_FLAG_NONE);
	pk_mem_bucket_set_client_mem_bucket(bkt);
	pkeSettings.isSimulationPaused = true;
	pk_ev_init(nullptr);
	PkeThreads_Init();
	AM_Init();
	ECS_Init();
	Physics_Init();
	pke_level_init();
	PkeCamera_Init();
	pke_scene_master_init();
	pke_input_init();
	FontType_Init();
	pke_ui_init();
	test_level = pke_level_create(test_level_name, pk_uuid_zed, pk_uuid_zed);
	// pk_funcinstr_teardown();
};

void pke_test_serialization_teardown() {
	// pk_funcinstr_init();
	pke_level_teardown(test_level);
	test_level = nullptr;
	pke_ui_teardown();
	FontType_Teardown();
	pke_input_teardown();
	pke_scene_master_teardown();
	PkeCamera_Teardown();
	Physics_Teardown();
	pke_level_teardown();
	ECS_Teardown();
	AM_Teardown();
	PkeThreads_Teardown();
	pk_ev_teardown();
	pk_mem_bucket_destroy(bkt);
	pk_mem_bucket_set_client_mem_bucket(nullptr);
	bkt = nullptr;
	// pk_funcinstr_teardown();
	pke_test_stub_teardown_vulkan();
};

int pke_test_serialization_999() {
	int64_t err_index = 0;
	pke_kve_container kvec{};
	pke_kve kve{};
	const pk_handle zed_handle = {0,0};
	PKE_TEST_ASSERT(kvec.srlztn_handle == zed_handle, err_index);

	PKE_TEST_ASSERT(kvec.type_code.length == 0, err_index);
	PKE_TEST_ASSERT(kvec.type_code.reserved == 0, err_index);
	PKE_TEST_ASSERT(kvec.type_code.val == nullptr, err_index);

	PKE_TEST_ASSERT(kvec.bkt == nullptr, err_index);

	// 6
	PKE_TEST_ASSERT(kvec.child_handles.next == 0, err_index);
	PKE_TEST_ASSERT(kvec.child_handles.reserved == 0, err_index);
	PKE_TEST_ASSERT(kvec.child_handles.stride == sizeof(pk_handle), err_index);
	PKE_TEST_ASSERT(kvec.child_handles.alignment == alignof(pk_handle), err_index);
	PKE_TEST_ASSERT(kvec.child_handles.bkt == nullptr, err_index);
	PKE_TEST_ASSERT(kvec.child_handles.data == nullptr, err_index);

	// 12
	PKE_TEST_ASSERT(kvec.children.next == 0, err_index);
	PKE_TEST_ASSERT(kvec.children.reserved == 0, err_index);
	PKE_TEST_ASSERT(kvec.children.stride == sizeof(pke_kve_container*), err_index);
	PKE_TEST_ASSERT(kvec.children.alignment == alignof(pke_kve_container*), err_index);
	PKE_TEST_ASSERT(kvec.children.bkt == nullptr, err_index);
	PKE_TEST_ASSERT(kvec.children.data == nullptr, err_index);

	// 18
	PKE_TEST_ASSERT(kvec.arr.next == 0, err_index);
	PKE_TEST_ASSERT(kvec.arr.reserved == 0, err_index);
	PKE_TEST_ASSERT(kvec.arr.stride == sizeof(pke_kve), err_index);
	PKE_TEST_ASSERT(kvec.arr.alignment == alignof(pke_kve), err_index);
	PKE_TEST_ASSERT(kvec.arr.bkt == nullptr, err_index);
	PKE_TEST_ASSERT(kvec.arr.data == nullptr, err_index);

	// 24
	PKE_TEST_ASSERT(kve.key == nullptr, err_index);
	PKE_TEST_ASSERT(kve.val == nullptr, err_index);
	PKE_TEST_ASSERT(kve.end == nullptr, err_index);
	return 0;
}

const char *const test_001_str = R"VOGON(:PKFB:
:0:

InstPos:00000000!00000000
Position:0.000000;1.000000;2.000000
Rotation:7.000000;8.000000;9.000000;6.000000
Scale:5.000000;4.000000;3.000000

:PKFE:)VOGON";
int pke_test_serialization_001() {
	pk_funcinstr_init();
	int64_t err_index = 0, i;
	srlztn_serialize_helper *h;
	std::stringstream ss;
	try {
		h = pke_serialize_init(bkt);

		glm::vec3 pos = glm::vec3(0,1,2);
		glm::quat rot = glm::quat(6,7,8,9);
		glm::vec3 scale = glm::vec3(5,4,3);
		pke_serialize_inst_pos(h, pos, rot, scale);

		pke_serialize_scene_to_stream(ss, h);

		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 3, err_index);
		for (i = 0; i < 3; ++i) {
			// 6,9,12
			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].key != nullptr, err_index);
			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].val != nullptr, err_index);
			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].end != nullptr, err_index);
		}

		std::string s = ss.str();
		// 15
		PKE_TEST_ASSERT(strstr(test_001_str, s.c_str()) != nullptr, err_index);

		pke_serialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	pk_funcinstr_teardown();
	return 0;
}

int pke_test_deserialization_101() {
	int64_t err_index = 0, i;
	srlztn_deserialize_helper *h;
	std::stringstream ss(test_001_str);
	try {
		h = pke_deserialize_init(test_level, bkt);

		pke_deserialize_scene_from_stream(ss, h);

		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 3, err_index);
		for (i = 0; i < 3; ++i) {
			// 6,9,12
			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].key != nullptr, err_index);
			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].val != nullptr, err_index);
			PKE_TEST_ASSERT(h->kvp_containers[0].arr[i].end != nullptr, err_index);
		}

		glm::vec3 pos;
		glm::quat rot;
		glm::vec3 scale;
		pke_deserialize_inst_pos(h, &h->kvp_containers[0], pos, rot, scale);

		// 15
		PKE_TEST_ASSERT(pos == glm::vec3(0,1,2), err_index);
		PKE_TEST_ASSERT(rot == glm::quat(6,7,8,9), err_index);
		PKE_TEST_ASSERT(scale == glm::vec3(5,4,3), err_index);

		pke_deserialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

const char *const test_002_str = R"VOGON(:PKFB:
:0:

InstPos:00000000!00000000
Rotation:0.000000;0.000000;0.000000;1.000000

Instance:00000000!00000001
ChildId:00000000!00000000
UUID:01010101-0101-0101-0101-010101010101
Mass:1.000000
CollisionLayer:0x0000000000000001
CollisionMask:0x0000000000000001

InstPos:00000000!00000002
Position:0.000000;-10.000000;-10.000000
Rotation:0.000000;0.000000;0.000000;1.000000
Scale:5.000000;4.000000;3.000000

Camera:00000000!00000003
ChildId:00000000!00000002
UUID:02020202-0202-0202-0202-020202020202
Type:0x01
Orientation:0x01
TargetUUID:01010101-0101-0101-0101-010101010101
IsPrimary:1

:PKFE:)VOGON";
int pke_test_serialization_002() {
	int64_t err_index = 0;
	uint32_t i, k;
	srlztn_serialize_helper *h = nullptr;
	pke_kve *kve = nullptr;
	std::stringstream ss;
	try {
		h = pke_serialize_init(bkt);

		// reminder that 'targeting' moves and rotates the camera, so we shouldn't see these values in the output
		InstPos cam_inst_pos{};
		cam_inst_pos.posRot.setIdentity();
		cam_inst_pos.posRot.setOrigin(btVector3(0,0,0));
		cam_inst_pos.posRot.setRotation(btQuaternion(0.f,0.f,0.f,1));
		cam_inst_pos.scale = btVector3(1,1,1);
		cam_inst_pos.mass = 1.f;

		Entity_Base *target_ent = ECS_CreateGenericEntity();
		CompInstance *target_ent_comp_inst = ECS_CreateInstance(target_ent, uuid_n[1], nullptr, &cam_inst_pos);

		cam_inst_pos.scale = btVector3(5,4,3);
		PkeCamera &cam = PkeCamera_Register(uuid_n[2], cam_inst_pos);
		cam.type = PKE_CAMERA_TYPE_PERSPECTIVE;
		cam.view = PKE_CAMERA_VIEW_TARGET;
		PkeCamera_SetPrimary(cam.camHandle);
		PkeCamera_TargetInstance(cam.camHandle, target_ent_comp_inst);

		pke_serialize_scene(h);
		pke_serialize_scene_to_stream(ss, h);
		std::string s = ss.str();

		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.next == 4, err_index);
		// instpos
		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 1, err_index);
		// instance
		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 4, err_index);
		// instpos
		PKE_TEST_ASSERT(h->kvp_containers[2].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[2].arr.next == 3, err_index);
		// camera
		PKE_TEST_ASSERT(h->kvp_containers[3].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[3].arr.next == 5, err_index);

		// 12
		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				// 12 + (3 * (1 + 4 + 3 + 5))
				kve = &h->kvp_containers[k].arr[i];
				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
			}
		}

		// 51
		PKE_TEST_ASSERT(strstr(test_002_str, s.c_str()) != nullptr, err_index);

		pke_serialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

int pke_test_deserialization_102() {
	int64_t err_index = 0;
	uint32_t i, k;
	pke_kve *kve;
	srlztn_deserialize_helper *h;
	std::stringstream ss(test_002_str);
	try {
		h = pke_deserialize_init(test_level, bkt);

		pke_deserialize_scene_from_stream(ss, h);

		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.next == 4, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[2].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[3].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 4, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[2].arr.next == 3, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[3].arr.next == 5, err_index);

		// 12
		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				// 12 + (3 * (1 + 4 + 3 + 5))
				kve = &h->kvp_containers[k].arr[i];
				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
			}
		}

		glm::vec3 pos = glm::vec3(0,0,0);
		glm::quat rot = glm::quat(1,0,0,0);
		glm::vec3 scale = glm::vec3(1,1,1);

		pke_deserialize_inst_pos(h, &h->kvp_containers[0], pos, rot, scale);
		// 51
		PKE_TEST_ASSERT(pos == glm::vec3(0,0,0), err_index);
		PKE_TEST_ASSERT(rot == glm::quat(1,0,0,0), err_index);
		PKE_TEST_ASSERT(scale == glm::vec3(1,1,1), err_index);

		pke_deserialize_inst_pos(h, &h->kvp_containers[2], pos, rot, scale);
		// 54
		PKE_TEST_ASSERT(pos == glm::vec3(0,-10,-10), err_index);
		PKE_TEST_ASSERT(rot == glm::quat(1,0,0,0), err_index);
		PKE_TEST_ASSERT(scale == glm::vec3(5,4,3), err_index);

		pke_deserialize_scene(h);

		PkeCamera *des_cam = PkeCamera_Get(CameraHandle{0,0});
		// 57
		PKE_TEST_ASSERT(des_cam != nullptr, err_index);
		PKE_TEST_ASSERT(des_cam->uuid == uuid_n[2], err_index);
		PKE_TEST_ASSERT(des_cam->type == PKE_CAMERA_TYPE_PERSPECTIVE, err_index);
		PKE_TEST_ASSERT(des_cam->view == PKE_CAMERA_VIEW_TARGET, err_index);
		PKE_TEST_ASSERT(des_cam->phys.target_inst_uuid == uuid_n[1], err_index);
		PKE_TEST_ASSERT(des_cam->isPrimary == true, err_index);

		pke_deserialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

const char *const test_003_str = R"VOGON(:PKFB:
:0:

FontRenderSettings:00000000!00000000
CharScale:1.000000
LineHeightScale:1.000000
CharSpacingScale:1.000000
SurfaceAreaSize:250;250
SurfaceAreaPos:0;0
SurfaceAreaFlags:0x03
ColorForeground:0.400000;0.900000;0.500000;0.800000
ColorBackground:0.000000;0.000000;0.000000;0.000000

FontRender:00000000!00000001
ChildId:00000000!00000000
UUID:01010101-0101-0101-0101-010101010101
FontTypeTitle:fnt_mquin_7y
TextBegin::
asdf
:MULTILINE_END:

UIBoxTypeData:00000000!00000002
FontRenderUUID:01010101-0101-0101-0101-010101010101

UIBox:00000000!00000003
ChildId:00000000!00000002
UUID:02020202-0202-0202-0202-020202020202
Flags:0x84
PosTopLeft:0.100000;0.100000
MaxSize:0.800000;0.800000
Type:0x32
Layer:0x00

:PKFE:)VOGON";
int pke_test_serialization_003() {
	int64_t err_index = 0;
	uint32_t i, k;
	srlztn_serialize_helper *h = nullptr;
	pke_kve *kve = nullptr;
	std::stringstream ss;
	try {
		h = pke_serialize_init(bkt);

		uint64_t idx_unused;
		FontRenderSettings frs;
		frs.char_scale = 1.0;
		frs.char_spacing_scale = 1.0;
		frs.line_height_scale = 1.0;
		frs.surface_area_size = glm::ivec2(250, 250);
		frs.surface_area_pos = glm::ivec2(0, 0);
		frs.surface_area_type_flags = FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH;
		FontRenderHandle fr_handle = FontType_AddStringRender(FontType_GetFonts(idx_unused)[0].index_ft, std::move(cstring_to_pk_cstr("asdf")), &frs, nullptr, uuid_n[1]);

		pke_ui_box *ui_box = pke_ui_box_new_root(PKE_UI_BOX_TYPE_TEXT, uuid_n[2]);
		ui_box->flags |= PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC;
		ui_box->pos_top_left.x = 0.1;
		ui_box->pos_top_left.y = 0.1;
		ui_box->max_size.x = 0.8;
		ui_box->max_size.y = 0.8;
		ui_box->type_data->text.font_render_handle = fr_handle;

		pke_serialize_scene(h);
		pke_serialize_scene_to_stream(ss, h);
		std::string s = ss.str();

		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.next == 4, err_index);
		// FontRenderSettings
		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 8, err_index);
		// FontRender
		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 3, err_index);
		// ui box type text
		PKE_TEST_ASSERT(h->kvp_containers[2].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[2].arr.next == 1, err_index);
		// ui box
		PKE_TEST_ASSERT(h->kvp_containers[3].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[3].arr.next == 6, err_index);

		// 12
		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				// 12 + (3 * (8 + 3 + 1 + 6))
				kve = &h->kvp_containers[k].arr[i];
				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
			}
		}

		// 66
		PKE_TEST_ASSERT(strstr(test_003_str, s.c_str()) != nullptr, err_index);

		pke_serialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

int pke_test_deserialization_103() {
	int64_t err_index = 0;
	uint32_t i, k;
	pke_kve *kve;
	srlztn_deserialize_helper *h;
	std::stringstream ss(test_003_str);
	try {
		h = pke_deserialize_init(test_level, bkt);

		pke_deserialize_scene_from_stream(ss, h);

		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.next == 4, err_index);
		// FontRenderSettings
		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 8, err_index);
		// FontRender
		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 3, err_index);
		// ui box type text
		PKE_TEST_ASSERT(h->kvp_containers[2].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[2].arr.next == 1, err_index);
		// ui box
		PKE_TEST_ASSERT(h->kvp_containers[3].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[3].arr.next == 6, err_index);

		// 12
		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				// 12 + (3 * (8 + 3 + 1 + 6))
				kve = &h->kvp_containers[k].arr[i];
				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
			}
		}

		pke_deserialize_scene(h);

		uint64_t idx_unused;
		FontType *fonts = FontType_GetFonts(idx_unused);
		// 66
		PKE_TEST_ASSERT(fonts != nullptr, err_index);
		PKE_TEST_ASSERT(idx_unused != 0xFFFFFFFFFFFFFFFF, err_index);
		PKE_TEST_ASSERT(fonts->n_render > FontRenderIndex{0}, err_index);
		FontRender *fr = &fonts[0].renders[0];

		// 69
		PKE_TEST_ASSERT(fr->settings.char_scale == 1.f, err_index);
		PKE_TEST_ASSERT(fr->settings.line_height_scale == 1.f, err_index);
		PKE_TEST_ASSERT(fr->settings.char_spacing_scale == 1.f, err_index);
		PKE_TEST_ASSERT(fr->settings.surface_area_size == glm::ivec2(250,250), err_index);
		PKE_TEST_ASSERT(fr->settings.surface_area_pos == glm::ivec2(0,0), err_index);
		PKE_TEST_ASSERT(fr->settings.surface_area_type_flags == FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH, err_index);
		// auto equal_4 = glm::epsilonEqual(fr->settings.color_foreground, glm::vec4(0.4, 0.9, 0.5, 0.8), epsilon_4);
		// PKE_TEST_ASSERT(equal_4 == bool_4, err_index);
		PKE_TEST_ASSERT(fr->settings.color_foreground == glm::vec4(0.4, 0.9, 0.5, 0.8), err_index);
		PKE_TEST_ASSERT(fr->settings.color_background == glm::vec4(0.0, 0.0, 0.0, 0.0), err_index);

		// 77
		PKE_TEST_ASSERT(fr->uuid == uuid_n[1], err_index);
		PKE_TEST_ASSERT(fr->text.val != nullptr, err_index);
		PKE_TEST_ASSERT(fr->text.val[0] == 'a', err_index);
		PKE_TEST_ASSERT(fr->text.val[1] == 's', err_index);
		PKE_TEST_ASSERT(fr->text.val[2] == 'd', err_index);
		PKE_TEST_ASSERT(fr->text.val[3] == 'f', err_index);
		PKE_TEST_ASSERT(fr->text.val[4] == '\0', err_index);

		// 84
		pke_ui_box_count_T count;
		pke_ui_box **boxes = pke_ui_get_root_boxes(&count);
		pke_ui_box *box = boxes[0];
		PKE_TEST_ASSERT(count == 1, err_index)
		PKE_TEST_ASSERT(box->internal.h_children == 0, err_index)
		PKE_TEST_ASSERT(box->type == PKE_UI_BOX_TYPE_TEXT, err_index)
		PKE_TEST_ASSERT(PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC), err_index)
		PKE_TEST_ASSERT(PK_HAS_FLAG(box->flags, PKE_UI_BOX_FLAG_VISIBILITY_INVISIBLE), err_index)

		pke_deserialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

const char *const test_004_str = R"VOGON(:PKFB:
:0:

UIBox:00000000!00000000
ChildId:00000000!00000001
UUID:02020202-0202-0202-0202-020202020202
Flags:0x02
PosTopLeft:1.000000;1.000000
MaxSize:1278.000000;718.000000
Type:0x00
Layer:0x00
ColorBorder:1.000000;0.000000;0.000000;1.000000
ColorBackground:0.200000;0.300000;0.200000;0.500000

UIBox:00000000!00000001
UUID:01010101-0101-0101-0101-010101010101
ParentUUID:02020202-0202-0202-0202-020202020202
Flags:0x04
PosTopLeft:0.100000;0.100000
MaxSize:0.800000;0.800000
Type:0x00
Layer:0x00
ColorBorder:1.000000;0.000000;0.000000;1.000000
ColorBackground:0.200000;0.300000;0.200000;0.500000

:PKFE:)VOGON";
int pke_test_serialization_004() {
	int64_t err_index = 0;
	uint32_t i, k;
	srlztn_serialize_helper *h = nullptr;
	pke_kve *kve = nullptr;
	std::stringstream ss;
	try {
		h = pke_serialize_init(bkt);

		pke_ui_box *ui_box_p = pke_ui_box_new_root(PKE_UI_BOX_TYPE_STANDARD, uuid_n[2]);
		ui_box_p->flags |= PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC;
		ui_box_p->pos_top_left.x = 1.f;
		ui_box_p->pos_top_left.y = 1.f;
		ui_box_p->max_size.x = 1278.f;
		ui_box_p->max_size.y = 718.f;

		pke_ui_box *ui_box_c = pke_ui_box_new_child(ui_box_p, PKE_UI_BOX_TYPE_STANDARD, uuid_n[1]);
		ui_box_c->flags |= PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC;
		ui_box_c->pos_top_left.x = 0.1;
		ui_box_c->pos_top_left.y = 0.1;
		ui_box_c->max_size.x = 0.8;
		ui_box_c->max_size.y = 0.8;

		pke_serialize_scene(h);
		pke_serialize_scene_to_stream(ss, h);
		std::string s = ss.str();

		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.next == 2, err_index);
		// ui box
		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 8, err_index);
		// ui box
		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 9, err_index);

		// 8
		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				// 8 + (3 * (9 + 8))
				kve = &h->kvp_containers[k].arr[i];
				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
			}
		}

		// 59
		PKE_TEST_ASSERT(strstr(test_004_str, s.c_str()) != nullptr, err_index);

		pke_serialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

int pke_test_deserialization_104() {
	int64_t err_index = 0;
	uint32_t i, k;
	srlztn_deserialize_helper *h = nullptr;
	pke_kve *kve = nullptr;
	std::stringstream ss(test_004_str);
	try {
		h = pke_deserialize_init(test_level, bkt);

		pke_deserialize_scene_from_stream(ss, h);

		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.next == 2, err_index);
		// ui box
		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 8, err_index);
		// ui box
		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 9, err_index);

		// 8
		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				// 8 + (3 * (9 + 8))
				kve = &h->kvp_containers[k].arr[i];
				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
			}
		}

		pke_deserialize_scene(h);

		pke_ui_box_count_T box_count;
		pke_ui_box **root_boxes = pke_ui_get_root_boxes(&box_count);
		// 59
		PKE_TEST_ASSERT(root_boxes != nullptr, err_index);
		PKE_TEST_ASSERT(box_count == 1, err_index);
		PKE_TEST_ASSERT(root_boxes[0] != nullptr, err_index);

		// 62
		PKE_TEST_ASSERT(root_boxes[0]->uuid == uuid_n[2], err_index);
		PKE_TEST_ASSERT(PK_HAS_FLAG(root_boxes[0]->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC), err_index);
		PKE_TEST_ASSERT(root_boxes[0]->pos_top_left == glm::vec2(1.f,1.f), err_index);
		PKE_TEST_ASSERT(root_boxes[0]->max_size == glm::vec2(1278.f,718.f), err_index);
		PKE_TEST_ASSERT(PK_HAS_FLAG(root_boxes[0]->type, PKE_UI_BOX_TYPE_STANDARD), err_index);
		PKE_TEST_ASSERT(root_boxes[0]->layer == 0, err_index);
		PKE_TEST_ASSERT(root_boxes[0]->internal.parent == nullptr, err_index);
		PKE_TEST_ASSERT(root_boxes[0]->internal.h_children == 1, err_index);
		PKE_TEST_ASSERT(root_boxes[0]->internal.children != nullptr, err_index);
		PKE_TEST_ASSERT(root_boxes[0]->internal.children[0] != nullptr, err_index);
		PKE_TEST_ASSERT(root_boxes[0]->color_border     == glm::vec4(1.0,0.0,0.0,1.0), err_index);
		PKE_TEST_ASSERT(root_boxes[0]->color_background == glm::vec4(0.2,0.3,0.2,0.5), err_index);

		pke_ui_box *box_c = root_boxes[0]->internal.children[0];
		// 74
		PKE_TEST_ASSERT(box_c->uuid == uuid_n[1], err_index);
		PKE_TEST_ASSERT(PK_HAS_FLAG(box_c->flags, PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC), err_index);
		PKE_TEST_ASSERT(box_c->pos_top_left == glm::vec2(0.1,0.1), err_index);
		PKE_TEST_ASSERT(box_c->max_size == glm::vec2(0.8,0.8), err_index);
		PKE_TEST_ASSERT(PK_HAS_FLAG(box_c->type, PKE_UI_BOX_TYPE_STANDARD), err_index);
		PKE_TEST_ASSERT(box_c->layer == 0, err_index);
		PKE_TEST_ASSERT(box_c->internal.parent == root_boxes[0], err_index);
		PKE_TEST_ASSERT(box_c->internal.h_children == 0, err_index);
		PKE_TEST_ASSERT(box_c->internal.children == nullptr, err_index);
		PKE_TEST_ASSERT(box_c->color_border     == glm::vec4(1.0,0.0,0.0,1.0), err_index);
		PKE_TEST_ASSERT(box_c->color_background == glm::vec4(0.2,0.3,0.2,0.5), err_index);

		pke_deserialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

/* Test empty FontRender text */
const char *const test_005_str = R"VOGON(:PKFB:
:0:

FontRenderSettings:00000000!00000000
CharScale:1.000000
LineHeightScale:1.000000
CharSpacingScale:1.000000
SurfaceAreaSize:250;250
SurfaceAreaPos:0;0
SurfaceAreaFlags:0x03
ColorForeground:0.400000;0.900000;0.500000;0.800000
ColorBackground:0.000000;0.000000;0.000000;0.000000

FontRender:00000000!00000001
ChildId:00000000!00000000
UUID:01010101-0101-0101-0101-010101010101
FontTypeTitle:fnt_mquin_7y
TextBegin::

:MULTILINE_END:

:PKFE:)VOGON";
int pke_test_serialization_005() {
	int64_t err_index = 0;
	uint32_t i, k;
	srlztn_serialize_helper *h = nullptr;
	pke_kve *kve = nullptr;
	std::stringstream ss;
	try {
		h = pke_serialize_init(bkt);

		uint64_t idx_unused;
		FontRenderSettings frs;
		frs.char_scale = 1.0;
		frs.char_spacing_scale = 1.0;
		frs.line_height_scale = 1.0;
		frs.surface_area_size = glm::ivec2(250, 250);
		frs.surface_area_pos = glm::ivec2(0, 0);
		frs.surface_area_type_flags = FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH;
		FontRenderHandle fr_handle = FontType_AddStringRender(FontType_GetFonts(idx_unused)[0].index_ft, cstring_to_pk_cstr(""), &frs, nullptr, uuid_n[1]);

		pke_serialize_scene(h);
		pke_serialize_scene_to_stream(ss, h);
		std::string s = ss.str();

		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.next == 2, err_index);
		// FontRenderSettings
		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 8, err_index);
		// FontRender
		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 3, err_index);

		// 8
		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				// 8 + (3 * (8 + 3))
				kve = &h->kvp_containers[k].arr[i];
				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
			}
		}

		// 41
		PKE_TEST_ASSERT(strstr(test_005_str, s.c_str()) != nullptr, err_index);

		pke_serialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

int pke_test_deserialization_105() {
	int64_t err_index = 0;
	uint32_t i, k;
	pke_kve *kve;
	srlztn_deserialize_helper *h;
	std::stringstream ss(test_005_str);
	try {
		h = pke_deserialize_init(test_level, bkt);

		pke_deserialize_scene_from_stream(ss, h);

		PKE_TEST_ASSERT(h->bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.bkt == bkt, err_index);
		PKE_TEST_ASSERT(h->kvp_containers.next == 2, err_index);
		// FontRenderSettings
		PKE_TEST_ASSERT(h->kvp_containers[0].child_handles.next == 0, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[0].arr.next == 8, err_index);
		// FontRender
		PKE_TEST_ASSERT(h->kvp_containers[1].child_handles.next == 1, err_index);
		PKE_TEST_ASSERT(h->kvp_containers[1].arr.next == 3, err_index);

		// 8
		for (k = 0; k < h->kvp_containers.next; ++k) {
			for (i = 0; i < h->kvp_containers[k].arr.next; ++i) {
				// 8 + (3 * (8 + 3))
				kve = &h->kvp_containers[k].arr[i];
				PKE_TEST_ASSERT(kve->key != nullptr, err_index);
				PKE_TEST_ASSERT(kve->val != nullptr, err_index);
				PKE_TEST_ASSERT(kve->end != nullptr, err_index);
			}
		}

		pke_deserialize_scene(h);

		uint64_t idx_unused;
		FontType *fonts = FontType_GetFonts(idx_unused);
		// 41
		PKE_TEST_ASSERT(fonts != nullptr, err_index);
		PKE_TEST_ASSERT(idx_unused != 0xFFFFFFFFFFFFFFFF, err_index);
		PKE_TEST_ASSERT(fonts->n_render > FontRenderIndex{0}, err_index);
		FontRender *fr = &fonts[0].renders[0];

		// 44
		PKE_TEST_ASSERT(fr->settings.char_scale == 1.f, err_index);
		PKE_TEST_ASSERT(fr->settings.line_height_scale == 1.f, err_index);
		PKE_TEST_ASSERT(fr->settings.char_spacing_scale == 1.f, err_index);
		PKE_TEST_ASSERT(fr->settings.surface_area_size == glm::ivec2(250,250), err_index);
		PKE_TEST_ASSERT(fr->settings.surface_area_pos == glm::ivec2(0,0), err_index);
		PKE_TEST_ASSERT(fr->settings.surface_area_type_flags == FONT_RENDER_SURFACE_AREA_TYPE_FLAGS_CENTER_BOTH, err_index);
		// auto equal_4 = glm::epsilonEqual(fr->settings.color_foreground, glm::vec4(0.4, 0.9, 0.5, 0.8), epsilon_4);
		// PKE_TEST_ASSERT(equal_4 == bool_4, err_index);
		PKE_TEST_ASSERT(fr->settings.color_foreground == glm::vec4(0.4, 0.9, 0.5, 0.8), err_index);
		PKE_TEST_ASSERT(fr->settings.color_background == glm::vec4(0.0, 0.0, 0.0, 0.0), err_index);

		// 52
		PKE_TEST_ASSERT(fr->uuid == uuid_n[1], err_index);
		PKE_TEST_ASSERT(fr->text.val != nullptr, err_index);
		PKE_TEST_ASSERT(fr->text.val[0] == '\0', err_index);

		pke_deserialize_teardown(h);

	} catch (const std::exception &ex) {
		throw;
	}
	return 0;
}

struct pk_test_group *pke_test_serialization_get_group() {
	static const uint64_t test_count = 11;
	static struct pk_test tests[test_count] = {
		{
			.title = "test 999",
			.func = pke_test_serialization_999,
			.expected_result = 0,
		},
		{
			.title = "test 001",
			.func = pke_test_serialization_001,
			.expected_result = 0,
		},
		{
			.title = "test 101",
			.func = pke_test_deserialization_101,
			.expected_result = 0,
		},
		{
			.title = "test 002",
			.func = pke_test_serialization_002,
			.expected_result = 0,
		},
		{
			.title = "test 102",
			.func = pke_test_deserialization_102,
			.expected_result = 0,
		},
		{
			.title = "test 003",
			.func = pke_test_serialization_003,
			.expected_result = 0,
		},
		{
			.title = "test 103",
			.func = pke_test_deserialization_103,
			.expected_result = 0,
		},
		{
			.title = "test 004",
			.func = pke_test_serialization_004,
			.expected_result = 0,
		},
		{
			.title = "test 104",
			.func = pke_test_deserialization_104,
			.expected_result = 0,
		},
		{
			.title = "test 005",
			.func = pke_test_serialization_005,
			.expected_result = 0,
		},
		{
			.title = "test 105",
			.func = pke_test_deserialization_105,
			.expected_result = 0,
		},
	};
	static struct pk_test_group group = {};
	group.title = "de/serialization";
	group.group_setup = nullptr;
	group.group_teardown = nullptr;
	group.test_setup = pke_test_serialization_spinup;
	group.test_teardown = pke_test_serialization_teardown;
	group.n_tests = test_count;
	group.tests = &tests[0];

	return &group;
}