internal class EntityManager
    {
        #region Constructor

        public EntityManager()
        {
            activeEntities = new List<Guid>();
            componentPools = new Dictionary<Type, object>();
            systems = new KeyedByTypeCollection<ISystem>();
        }

        #endregion Constructor

        #region Variables

        private List<Guid> activeEntities;
        private Dictionary<Type, object> componentPools;
        private KeyedByTypeCollection<ISystem> systems;

        #endregion Variables

        #region Properties

        public IReadOnlyList<ISystem> Systems { get { return systems; } }

        #endregion Properties

        #region Methods

        public Guid CreateEntity()
        {
            Guid entityId = GenerateEntityId();
            activeEntities.Add(entityId);

            UpdateSystems((system) =>
            {
                if (system.ComponentRequirements.IsEmpty)
                    AddEntityToSystemCache(system, entityId);
            });

            return entityId;
        }

        public void DestroyEntity(Guid entityId)
        {
            activeEntities.Remove(entityId);
            RemoveEntityFromComponentPools(entityId);

            UpdateSystems((system) =>
            {
                RemoveEntityFromSystemCache(system, entityId);
            });
        }

        public void AddComponentToEntity<TComponent>(Guid entityId, TComponent component) where TComponent : IComponent
        {
            AddEntityToComponentPool(entityId, component);

            Type[] componentTypes = GetComponentTypesFromEntityById(entityId);

            UpdateSystems((system) =>
            {
                if (system.ComponentRequirements.ValidateEntity(componentTypes))
                    AddEntityToSystemCache(system, entityId);
            });
        }

        public void RemoveComponentFromEntity<TComponent>(Guid entityId) where TComponent : IComponent
        {
            RemoveEntityFromComponentPool<TComponent>(entityId);

            UpdateSystems((system) =>
            {
                if (ComponentIsRequiredBySystem<TComponent>(system))
                    RemoveEntityFromSystemCache(system, entityId);
            });
        }

        private Guid GenerateEntityId()
        {
            return Guid.NewGuid();
        }

        private void AddEntityToComponentPool<TComponent>(Guid entityId, TComponent component) where TComponent : IComponent
        {
            GetComponentPoolByType<TComponent>().Add(entityId, component);
        }

        private void RemoveEntityFromComponentPool<TComponent>(Guid entityId) where TComponent : IComponent
        {
            GetComponentPoolByType<TComponent>().Remove(entityId);
        }

        private void RemoveEntityFromComponentPools(Guid entityId)
        {
            foreach (KeyValuePair<Type, object> componentPool in componentPools)
            {
                Dictionary<Guid, object> typedTargetPool = (Dictionary<Guid, object>)componentPool.Value;
                typedTargetPool.Remove(entityId);
            }
        }

        private void AddEntityToSystemCache(ISystem system, Guid entityId)
        {
            system.EntityCache.Add(entityId);
        }

        private void RemoveEntityFromSystemCache(ISystem system, Guid entityId)
        {
            system.EntityCache.Remove(entityId);
        }

        private bool ComponentIsRequiredBySystem<TComponent>(ISystem system) where TComponent : IComponent
        {
            return system.ComponentRequirements.ComponentIsRequired<TComponent>();
        }

        private void UpdateSystems(Action<ISystem> systemUpdateAction)
        {
            foreach (ISystem system in systems)
            {
                systemUpdateAction(system);
            }
        }

        public void AddComponentPool<TComponent>() where TComponent : IComponent
        {
            componentPools.Add(typeof(TComponent), new Dictionary<Guid, TComponent>());
        }

        public void RemoveComponentPool<TComponent>() where TComponent : IComponent
        {
            if (!ComponentPoolIsRequiredBySystems<TComponent>())
            {
                componentPools.Remove(typeof(TComponent));
            }
        }

        public Dictionary<Guid, TComponent> GetComponentPoolByType<TComponent>() where TComponent : IComponent
        {
            object targetPool = componentPools[typeof(TComponent)];
            return (Dictionary<Guid, TComponent>)targetPool;
        }

        private Type[] GetComponentTypesFromEntityById(Guid entityId)
        {
            return componentPools
                    .Where(pool => ((IDictionary)pool.Value)
                    .Contains(entityId))
                    .Select(componentType => componentType.Key)
                    .ToArray();
        }

        private bool ComponentPoolIsRequiredBySystems<TComponent>() where TComponent : IComponent
        {
            return systems.Any(system => system.ComponentRequirements.ComponentIsRequired<TComponent>());
        }

        public void AddSystem<TSystem>(TSystem system) where TSystem : ISystem
        {
            systems.Add(system);
            ValidateActiveEntities(system);
        }

        public void RemoveSystem<TSystem>() where TSystem : ISystem
        {
            systems.Remove(typeof(TSystem));
        }

        private void ValidateActiveEntities<TSystem>(TSystem system) where TSystem : ISystem
        {
            for (int i = 0; i < activeEntities.Count; i++)
            {
                Guid entityId = activeEntities[i];
                Type[] componentTypes = GetComponentTypesFromEntityById(entityId);

                if (ValidateEntityByComponents(system, componentTypes))
                {
                    AddEntityToSystemCache(system, entityId);
                }
            }
        }

        private bool ValidateEntityByComponents<TSystem>(TSystem system, Type[] componentTypes) where TSystem : ISystem
        {
            return system.ComponentRequirements.ValidateEntity(componentTypes);
        }

        private void AddEntityToSystemCache<TSystem>(TSystem system, Guid entityId) where TSystem : ISystem
        {
            system.EntityCache.Add(entityId);
        }

        #endregion Methods
    }