#include <iostream>
#include <stdarg.h>
#include <vector>

class IComponent {
public:
	virtual uint32_t GetID() const = 0;
};

template <uint32_t ID>
class Component : public IComponent {
public:
	virtual ~Component() { }

public:
	constexpr static size_t TypeID = (1u << ID);
	virtual size_t GetID() const override { return TypeID; }
};

class RenderComponent : public Component<0> {
public:
	virtual ~RenderComponent() { }

public:
	uint32_t m_vboID;
};

class PhysicsComponent : public Component<1> {
public:
	virtual ~PhysicsComponent() { }

public:
	float m_Speed;
	float m_Size;
};

class PositionComponent : public Component<2> {
public:
	virtual ~PositionComponent() { }

public:
	float m_X, m_Y, m_Z;
};

class Entity {
public:
	Entity()
		: m_Mask(NULL)
	{

	}

	virtual ~Entity() { }

public:
	void AddComponent(IComponent* component)
	{
		m_Mask |= component->GetID();
		m_Components.push_back(component);
	}

public:
	uint32_t m_ID;
	uint32_t m_Mask;
	std::vector<IComponent*> m_Components;
};

class IProcessor {
public:
	virtual void Process(std::vector<Entity*>& entities) = 0;
	virtual uint32_t GetMask() = 0;
};

template <class Type, uint32_t Mask>
class Processor {
public:
	virtual ~Processor() { }

public:
	virtual void Process(std::vector<Entity*>& entities)
	{
		for (auto entity : entities)
		{
			if ((entity->m_Mask & Mask) == Mask)
			{
				static_cast<Type*>(this)->Process(*entity);
			}
		}
	}
};

class PhysicsProcessor : public Processor<PhysicsProcessor, PhysicsComponent::TypeID | PositionComponent::TypeID> {
public:
	virtual ~PhysicsProcessor() { }

public:
	virtual void Process(Entity& entity)
	{
		printf("PhysicsAndMovement %d\n", entity.m_ID);
	}
};

class EntityManager {
public:
	virtual ~EntityManager() { }

public:
	void Update(float delta)
	{
		for (auto processor : m_Processors)
		{
			processor->Process(m_Entities);
		}
	}

	Entity* CreateEntity()
	{
		Entity* nEntity = new Entity();
		nEntity->m_ID = m_Entities.size() + 1;
		m_Entities.push_back(nEntity);
		return nEntity;
	}

private:
	std::vector<IProcessor*> m_Processors;
	std::vector<Entity*> m_Entities;
};

int main(int argc, char* argv[])
{
	EntityManager manager;
	Entity* entityA = manager.CreateEntity();

	PhysicsComponent pC;
	pC.m_Size = 2.0f;
	pC.m_Speed = 1.0f;

	RenderComponent rC;
	rC.m_vboID = 5;

	PositionComponent psC;
	psC.m_X = 23.5f;
	psC.m_Y = 1.0f;
	psC.m_Z = 500.2f;

	entityA->AddComponent(&pC);
	entityA->AddComponent(&rC);
	entityA->AddComponent(&psC);
	std::cout << entityA->m_Mask << std::endl;

	manager.Update(16.666f);

	system("PAUSE");
	return EXIT_SUCCESS;
}