#include <iostream>
#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), m_ID(0xFFFFFFFF)
    {

    }

    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;
};

template <class Type, uint32_t Mask>
class Processor : public IProcessor {
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 SetProcessor(IProcessor* processor)
    {
        m_Processors.push_back(processor);
    }

    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;
    IProcessor* a = new PhysicsProcessor();
    manager.SetProcessor(a);

    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);

    manager.Update(16.666f);

    system("PAUSE");
    return EXIT_SUCCESS;
}