#include "./pke-test-static-ui.h"

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

#include "ecs.hpp"
#include "pke-test-stubs.h"
#include "player-input.hpp"
#include "window.hpp"
#include "vendor-glm-include.hpp"
#include <limits>

struct pke_ui_box_instance_buffer_item {
	glm::mat4 pos_scale;
	glm::vec2 px_scale;
	float depth;
	float padding[1];
};
struct pke_ui_flex_params {
	float px_per_unit;
	float unit_total;
	float used_units;
};

#define PKE_TEST_EXPOSE
#include "static-ui.hpp"

static pk_membucket *bkt;

static VkExtent2D test_extent = { 1920, 1080 };

void pke_test_static_ui_setup() {
	pke_test_stub_init_vulkan();
	bkt = pk_mem_bucket_create("pke_test_static_ui", PK_MEM_DEFAULT_BUCKET_SIZE, PK_MEMBUCKET_FLAG_NONE);
	pk_mem_bucket_set_client_mem_bucket(bkt);
	Extent.width = test_extent.width;
	Extent.height = test_extent.height;
	pk_ev_init(nullptr);
	ECS_Init();
	pke_input_init();
	pke_ui_init();
}

void pke_test_static_ui_teardown() {
	pke_ui_teardown();
	ECS_Teardown();
	pk_ev_teardown();
	pke_input_teardown();
	pk_mem_bucket_destroy(bkt);
	pk_mem_bucket_set_client_mem_bucket(nullptr);
	bkt = nullptr;
	pke_test_stub_teardown_vulkan();
}

// test static
int pke_test_static_ui_000() {
	pk_arr_t<pke_ui_box_instance_buffer_item> arr{};
	pk_arr_t<std::pair<pke_ui_box*,pke_ui_box_instance_buffer_item>> txtr_arr{};
	float calculated_offset;
	uint8_t err_index = 0;

	pke_ui_box *ui_box = pke_ui_box_new_root();
	ui_box->flags = PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC;
	ui_box->pos_top_left.x = 10;
	ui_box->pos_top_left.y = 10;
	ui_box->max_size.x = 500;
	ui_box->max_size.y = 500;

	pke_ui_box *c_ui_box = pke_ui_box_new_child(ui_box);
	c_ui_box->flags = PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC;
	c_ui_box->pos_top_left.x = 10;
	c_ui_box->pos_top_left.y = 10;
	c_ui_box->max_size.x = 100;
	c_ui_box->max_size.y = 100;

	calculated_offset = ui_box->pos_top_left.x + c_ui_box->pos_top_left.x + built_in_offset;

	pke_ui_calc_px(arr, txtr_arr, nullptr, ui_box, 0);
	pke_ui_recalc_sizes_recursive(arr, txtr_arr, ui_box);

	PKE_TEST_ASSERT(ui_box->internal.parent == nullptr, err_index);
	PKE_TEST_ASSERT(ui_box->internal.h_children == 1, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.parent != nullptr, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.h_children == 0, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.r_children == 0, err_index);

	PKE_TEST_ASSERT(ui_box->internal.px_corner.x == 10, err_index);
	PKE_TEST_ASSERT(ui_box->internal.px_corner.y == 10, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.px_corner.x == calculated_offset, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.px_corner.y == calculated_offset, err_index);

	PKE_TEST_ASSERT(ui_box->internal.px_size.x == 500, err_index);
	PKE_TEST_ASSERT(ui_box->internal.px_size.y == 500, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.px_size.x == 100, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.px_size.y == 100, err_index);

	return 0;
}

// test dynamic
int pke_test_static_ui_100() {
	pk_arr_t<pke_ui_box_instance_buffer_item> arr{};
	pk_arr_t<std::pair<pke_ui_box*,pke_ui_box_instance_buffer_item>> txtr_arr{};
	bool b;
	float unit;
	float calculated_offset_x, calculated_offset_y;
	uint8_t err_index = 0;

	pke_ui_box *ui_box = pke_ui_box_new_root();
	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;

	pke_ui_box *c_ui_box = pke_ui_box_new_child(ui_box);
	c_ui_box->flags = PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC;
	c_ui_box->pos_top_left.x = 0.1;
	c_ui_box->pos_top_left.y = 0.1;
	c_ui_box->max_size.x = 0.8;
	c_ui_box->max_size.y = 0.8;

	pke_ui_calc_px(arr, txtr_arr, nullptr, ui_box, 0);
	pke_ui_recalc_sizes_recursive(arr, txtr_arr, ui_box);

	unit = Extent.width * 0.1;
	calculated_offset_x = (unit * 8) - (built_in_offset * 2); // padded parent
	calculated_offset_x = (calculated_offset_x * 0.1) + unit + built_in_offset;

	unit = Extent.height * 0.1;
	calculated_offset_y = (unit * 8) - (built_in_offset * 2); // padded parent
	calculated_offset_y = (calculated_offset_y * 0.1) + unit + built_in_offset;

	PKE_TEST_ASSERT(ui_box->internal.parent == nullptr, err_index);
	PKE_TEST_ASSERT(ui_box->internal.h_children == 1, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.parent != nullptr, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.h_children == 0, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.r_children == 0, err_index);

	PKE_TEST_ASSERT(ui_box->internal.px_corner.x == Extent.width * 0.1, err_index);
	PKE_TEST_ASSERT(ui_box->internal.px_corner.y == Extent.height * 0.1, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.px_corner.x == calculated_offset_x, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.px_corner.y == calculated_offset_y, err_index);

	PKE_TEST_ASSERT(ui_box->internal.px_size.x == (Extent.width * 0.1) * 8, err_index);
	PKE_TEST_ASSERT(ui_box->internal.px_size.y == (Extent.height * 0.1) * 8, err_index);
	b = flt_equal<float>(
			c_ui_box->internal.px_size.x,
			(ui_box->internal.px_size.x - (built_in_offset * 2)) * 0.8,
			std::numeric_limits<float>::epsilon());
	PKE_TEST_ASSERT(b, err_index);
	b = flt_equal<float>(
			c_ui_box->internal.px_size.y,
			(ui_box->internal.px_size.y - (built_in_offset * 2)) * 0.8,
			std::numeric_limits<float>::epsilon());
	PKE_TEST_ASSERT(b, err_index);

	return 0;
}


// test dynamic + static
int pke_test_static_ui_200() {
	pk_arr_t<pke_ui_box_instance_buffer_item> arr{};
	pk_arr_t<std::pair<pke_ui_box*,pke_ui_box_instance_buffer_item>> txtr_arr{};
	float unit;
	float calculated_offset_x, calculated_offset_y;
	uint8_t err_index = 0;

	pke_ui_box *ui_box = pke_ui_box_new_root();
	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;

	pke_ui_box *c_ui_box = pke_ui_box_new_child(ui_box);
	c_ui_box->flags = PKE_UI_BOX_FLAG_POSITION_TYPE_STATIC;
	c_ui_box->pos_top_left.x = 1;
	c_ui_box->pos_top_left.y = 1;
	c_ui_box->max_size.x = 300;
	c_ui_box->max_size.y = 300;

	unit = Extent.width * 0.1;
	calculated_offset_x = unit + 1 + built_in_offset;

	unit = Extent.height * 0.1;
	calculated_offset_y = unit + 1 + built_in_offset;

	pke_ui_calc_px(arr, txtr_arr, nullptr, ui_box, 0);
	pke_ui_recalc_sizes_recursive(arr, txtr_arr, ui_box);

	PKE_TEST_ASSERT(ui_box->internal.parent == nullptr, err_index);
	PKE_TEST_ASSERT(ui_box->internal.h_children == 1, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.parent != nullptr, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.h_children == 0, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.r_children == 0, err_index);

	PKE_TEST_ASSERT(ui_box->internal.px_corner.x == Extent.width * 0.1, err_index);
	PKE_TEST_ASSERT(ui_box->internal.px_corner.y == Extent.height * 0.1, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.px_corner.x == calculated_offset_x, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.px_corner.y == calculated_offset_y, err_index);

	PKE_TEST_ASSERT(ui_box->internal.px_size.x == (Extent.width * 0.1) * 8, err_index);
	PKE_TEST_ASSERT(ui_box->internal.px_size.y == (Extent.height * 0.1) * 8, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.px_size.x == 300, err_index);
	PKE_TEST_ASSERT(c_ui_box->internal.px_size.y == 300, err_index);

	return 0;
}

// test flex with padding
int pke_test_static_ui_300() {
	pk_arr_t<pke_ui_box_instance_buffer_item> arr{};
	pk_arr_t<std::pair<pke_ui_box*,pke_ui_box_instance_buffer_item>> txtr_arr{};
	unsigned int u;
	float flex_box_height;
	const uint8_t child_count = 5;
	pke_ui_box *c_ui_boxes[child_count];

	pke_ui_box *ui_box = pke_ui_box_new_root();
	ui_box->flags |= PKE_UI_BOX_FLAG_POSITION_TYPE_DYNAMIC;
	ui_box->flags |= PKE_UI_BOX_FLAG_CENTER_BOTH;
	ui_box->flex_direction = 1;
	ui_box->flex_padding = 1;
	ui_box->pos_top_left.x = 0;
	ui_box->pos_top_left.y = 0;
	ui_box->min_size.x = 0;
	ui_box->min_size.y = 0;
	ui_box->max_size.x = 0.95;
	ui_box->max_size.y = 0.95;

	for (u = 0; u < child_count; ++u) {
		c_ui_boxes[u] = pke_ui_box_new_child(ui_box);
		c_ui_boxes[u]->flags |= PKE_UI_BOX_FLAG_POSITION_TYPE_FLEX;
		c_ui_boxes[u]->flex_weight = 1;
		c_ui_boxes[u]->pos_top_left.x = 0;
		c_ui_boxes[u]->pos_top_left.y = 0;
		c_ui_boxes[u]->min_size.x = 0;
		c_ui_boxes[u]->min_size.y = 0;
		c_ui_boxes[u]->max_size.x = 8000;
		c_ui_boxes[u]->max_size.y = 8000;
	}

	pke_ui_calc_px(arr, txtr_arr, nullptr, ui_box, 0);
	pke_ui_recalc_sizes_recursive(arr, txtr_arr, ui_box);

	PK_TEST_ASSERT_EQ_RET(nullptr, ui_box->internal.parent);
	PK_TEST_ASSERT_EQ_RET(child_count, ui_box->internal.h_children);
	PK_TEST_ASSERT_EQ_RET(48, ui_box->internal.px_corner.x);
	PK_TEST_ASSERT_EQ_RET(27, ui_box->internal.px_corner.y);
	PK_TEST_ASSERT_EQ_RET(1824, ui_box->internal.px_size.x);
	PK_TEST_ASSERT_EQ_RET(1026, ui_box->internal.px_size.y);

	flex_box_height = 1016 / float(child_count);
	for (u = 0; u < child_count; ++u) {
		PK_TEST_ASSERT_NEQ_RET(nullptr, c_ui_boxes[u]->internal.parent);
		PK_TEST_ASSERT_EQ_RET(0, c_ui_boxes[u]->internal.h_children);
		PK_TEST_ASSERT_EQ_RET(0, c_ui_boxes[u]->internal.r_children);
		PK_TEST_ASSERT_EQ_RET(1820, c_ui_boxes[u]->internal.px_size.x);
		// (((parent-size - parent border (both) - built-in-padding (both) - flex padding(total)) / child_count
		// (((1026        - 2)                   - 2)                      - 6)                   / 5
		PK_TEST_ASSERT_EQ_RET(1016 / float(child_count), c_ui_boxes[u]->internal.px_size.y);
		PK_TEST_ASSERT_EQ_RET(flex_box_height, c_ui_boxes[u]->internal.px_size.y);
		// parent pos + parent border + built-in-padding
		PK_TEST_ASSERT_EQ_RET(48 + 1 + 1, c_ui_boxes[u]->internal.px_corner.x);
	}

	// (pos calc) + parent_pos + parent_border + built-in-padding + flex padding
	PK_TEST_ASSERT_EQ_RET((flex_box_height * 0) + 27 + 1 + 1 + 1, c_ui_boxes[0]->internal.px_corner.y);
	PK_TEST_ASSERT_EQ_RET((flex_box_height * 1) + 27 + 1 + 1 + 2, c_ui_boxes[1]->internal.px_corner.y);
	PK_TEST_ASSERT_EQ_RET((flex_box_height * 2) + 27 + 1 + 1 + 3, c_ui_boxes[2]->internal.px_corner.y);
	PK_TEST_ASSERT_EQ_RET((flex_box_height * 3) + 27 + 1 + 1 + 4, c_ui_boxes[3]->internal.px_corner.y);
	PK_TEST_ASSERT_EQ_RET((flex_box_height * 4) + 27 + 1 + 1 + 5, c_ui_boxes[4]->internal.px_corner.y);

	return 0;
}

pk_test_group *pke_test_static_ui_get_group() {
	static const uint64_t test_count = 4;
	static struct pk_test tests[test_count] = {
		{
			.title = "test 000",
			.func = pke_test_static_ui_000,
			.expected_result = 0,
		},
		{
			.title = "test 100",
			.func = pke_test_static_ui_100,
			.expected_result = 0,
		},
		{
			.title = "test 200",
			.func = pke_test_static_ui_200,
			.expected_result = 0,
		},
		{
			.title = "test 300",
			.func = pke_test_static_ui_300,
			.expected_result = 0,
		},
	};
	static struct pk_test_group group = {};
	group.title = "static_ui";
	group.group_setup = NULL;
	group.group_teardown = NULL;
	group.test_setup = pke_test_static_ui_setup;
	group.test_teardown = pke_test_static_ui_teardown;
	group.tests = &tests[0];
	group.n_tests = test_count;

	return &group;
}