#include <psemek/test/test.hpp>

#include <psemek/ecs/entity_container.hpp>
#include <psemek/ecs/declare_uuid.hpp>
#include <psemek/random/generator.hpp>
#include <psemek/random/uniform.hpp>

using namespace psemek;
using namespace psemek::ecs;

namespace
{

	struct component_1
	{
		int value;

		psemek_declare_uuid("component_1")
	};

	struct component_2
	{
		int value;

		psemek_declare_uuid("component_2")
	};

}

test_case(ecs_apply_empty)
{
	entity_container container;

	int const count = 2048;
	for (int i = 0; i < count; ++i)
		container.create();

	int call_count = 0;
	container.apply<>([&](entity_container &, entity_handle const &){ ++call_count; });
	container.apply<>([&](entity_container &){ ++call_count; });
	container.apply<>([&](entity_handle const &){ ++call_count; });
	container.apply<>([&]{ ++call_count; });
	expect_equal(count * 4, call_count);
}

test_case(ecs_apply_components_1)
{
	entity_container container;
	random::generator rng;

	int const expected_count = 1024 * 1024;
	int expected_sum = 0;

	for (int i = 0; i < expected_count; ++i)
	{
		int value = random::uniform(rng, -1024, 1024);
		expected_sum += value;
		container.create(component_1{value});
	}

	int count = 0;
	int sum = 0;
	container.apply<component_1>([&](component_1 const & component){
		++count;
		sum += component.value;
	});

	expect_equal(count, expected_count);
	expect_equal(sum, expected_sum);
}

test_case(ecs_apply_components_2)
{
	entity_container container;
	random::generator rng;

	int const expected_count = 1024*1024;
	int expected_sum = 0;

	for (int i = 0; i < expected_count; ++i)
	{
		int value = random::uniform(rng, -1024, 1024);
		int type = random::uniform(rng, 0, 2);
		if (type == 0)
			container.create(component_1{value});
		else if (type == 1)
			container.create(component_2{value});
		else if (type == 2)
			container.create(component_1{value}, component_2{value});

		expected_sum += value;
	}

	int count = 0;
	int sum = 0;
	container.apply<component_1>([&](component_1 const & component){
		++count;
		sum += component.value;
	});
	container.apply<component_2>([&](component_2 const & component){
		++count;
		sum += component.value;
	});
	container.apply<component_1, component_2>([&](component_1 const & component1, component_2 const &){
		--count;
		sum -= component1.value;
	});

	expect_equal(count, expected_count);
	expect_equal(sum, expected_sum);
}