using System;
using System.Reflection;
using System.Collections.Generic;
using System.Linq;
using Encompass.Exceptions;

namespace Encompass
{
    public abstract class Engine
    {
        internal readonly HashSet<Type> sendTypes = new HashSet<Type>();
        internal readonly HashSet<Type> readTypes = new HashSet<Type>();
        internal readonly HashSet<Type> activateTypes = new HashSet<Type>();
        internal readonly HashSet<Type> updateTypes = new HashSet<Type>();

        private EntityManager entityManager;
        private ComponentManager componentManager;
        private MessageManager messageManager;

        protected Engine()
        {
            var writesAttribute = GetType().GetCustomAttribute<Sends>(false);
            if (writesAttribute != null)
            {
                sendTypes = writesAttribute.sendTypes;
            }

            var readsAttribute = GetType().GetCustomAttribute<Reads>(false);
            if (readsAttribute != null)
            {
                readTypes = readsAttribute.readTypes;
            }

            var activatesAttribute = GetType().GetCustomAttribute<Activates>(false);
            if (activatesAttribute != null)
            {
                activateTypes = activatesAttribute.activateTypes;
            }

            var updatesAttribute = GetType().GetCustomAttribute<Updates>(false);
            if (updatesAttribute != null)
            {
                updateTypes = updatesAttribute.updateTypes;
                if (sendTypes.Any())
                {
                    throw new IllegalEngineAttributesException("Engine {0} sends Message(s) and updates Component(s)", GetType().Name);
                }
            }
        }

        internal void AssignEntityManager(EntityManager entityManager)
        {
            this.entityManager = entityManager;
        }

        internal void AssignComponentManager(ComponentManager componentManager)
        {
            this.componentManager = componentManager;
        }

        internal void AssignMessageManager(MessageManager messageManager)
        {
            this.messageManager = messageManager;
        }

        public abstract void Update(double dt);

        protected Entity CreateEntity()
        {
            return entityManager.CreateEntity();
        }

        protected bool EntityExists(Guid entityID)
        {
            return entityManager.EntityExists(entityID);
        }

        protected Entity GetEntity(Guid entityID)
        {
            return entityManager.GetEntity(entityID);
        }

        protected Guid GetEntityIDByComponentID(Guid componentID)
        {
            return componentManager.GetEntityIDByComponentID(componentID);
        }

        protected Entity GetEntityByComponentID(Guid componentID)
        {
            return GetEntity(GetEntityIDByComponentID(componentID));
        }

        protected TComponent GetComponentByID<TComponent>(Guid componentID) where TComponent : struct, IComponent
        {
            if (componentManager.GetComponentTypeByID(componentID) != typeof(TComponent))
            {
                throw new ComponentTypeMismatchException("Expected Component to be of type {0} but was actually of type {1}", typeof(TComponent).Name, componentManager.GetComponentTypeByID(componentID).Name);
            }

            return (TComponent)componentManager.GetComponentByID(componentID);
        }

        internal IEnumerable<ValueTuple<Entity, Guid, TComponent>> ReadComponentsFromWorld<TComponent>() where TComponent : struct, IComponent
        {
            return componentManager.GetActiveComponentsByType<TComponent>().Select((triple) => (GetEntity(triple.Item1), triple.Item2, triple.Item3));
        }

        protected Guid AddComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent
        {
            if (!activateTypes.Contains(typeof(ComponentMessage<TComponent>)))
            {
                throw new IllegalActivateException("Engine {0} tried to activate undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
            }

            var componentID = componentManager.AddComponent(entity.ID, component);

            ComponentMessage<TComponent> componentMessage;
            componentMessage.entity = entity;
            componentMessage.componentID = componentID;
            componentMessage.component = component;
            SendMessage(componentMessage);

            return componentID;
        }

        protected Guid AddDrawComponent<TComponent>(Entity entity, TComponent component, int layer = 0) where TComponent : struct, IComponent
        {
            if (!activateTypes.Contains(typeof(ComponentMessage<TComponent>)))
            {
                throw new IllegalActivateException("Engine {0} tried to activate undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
            }

            var componentID = componentManager.AddDrawComponent(entity.ID, component, layer);

            ComponentMessage<TComponent> componentMessage;
            componentMessage.entity = entity;
            componentMessage.componentID = componentID;
            componentMessage.component = component;
            SendMessage(componentMessage);

            return componentID;
        }

        protected void ActivateComponent<TComponent>(Guid componentID) where TComponent : struct, IComponent
        {
            if (!activateTypes.Contains(typeof(ComponentMessage<TComponent>)))
            {
                throw new IllegalActivateException("Engine {0} tried to activate undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
            }

            var entity = GetEntity(componentManager.GetEntityIDByComponentID(componentID));
            var component = GetComponentByID<TComponent>(componentID);

            ComponentMessage<TComponent> componentMessage;
            componentMessage.entity = entity;
            componentMessage.componentID = componentID;
            componentMessage.component = component;
            SendMessage(componentMessage);

            componentManager.Activate(componentID);
        }

        protected void DeactivateComponent(Guid componentID)
        {
            componentManager.MarkForDeactivation(componentID);
        }

        protected IEnumerable<ValueTuple<Guid, TComponent>> GetComponents<TComponent>(Entity entity) where TComponent : struct, IComponent
        {
            if (!readTypes.Contains(typeof(ComponentMessage<TComponent>)))
            {
                throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
            }

            return ReadMessages<ComponentMessage<TComponent>>().Where((message) => message.entity == entity).Select((message) => (message.componentID, message.component));
        }

        protected ValueTuple<Guid, TComponent> GetComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
        {
            return GetComponents<TComponent>(entity).First();
        }

        protected bool HasComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
        {
            if (!readTypes.Contains(typeof(ComponentMessage<TComponent>)))
            {
                throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
            }

            return ReadMessages<ComponentMessage<TComponent>>().Where((message) => message.entity == entity).Any();
        }

        internal void UpdateComponentInWorld<TComponent>(Guid componentID, TComponent newComponent) where TComponent : struct, IComponent
        {
            if (!updateTypes.Contains(typeof(TComponent)))
            {
                throw new IllegalWriteException("Engine {0} tried to write undeclared Component {1}", this.GetType().Name, typeof(TComponent).Name);
            }

            componentManager.AddUpdateComponentOperation(componentID, newComponent);
        }

        protected void UpdateComponent<TComponent>(Guid componentID, TComponent newComponentValue) where TComponent : struct, IComponent
        {
            UpdateComponentInWorld(componentID, newComponentValue);
        }

        protected void SendMessage<TMessage>(TMessage message) where TMessage : struct, IMessage
        {
            if (!sendTypes.Contains(typeof(TMessage)))
            {
                throw new IllegalWriteException("Engine {0} tried to write undeclared Message {1}", this.GetType().Name, typeof(TMessage).Name);
            }

            messageManager.AddMessage(message);
        }

        protected IEnumerable<TMessage> ReadMessages<TMessage>() where TMessage : struct, IMessage
        {
            if (!readTypes.Contains(typeof(TMessage)))
            {
                throw new IllegalReadException("Engine {0} tried to read undeclared Message {1}", this.GetType().Name, typeof(TMessage).Name);
            }

            return messageManager.GetMessagesByType<TMessage>();
        }

        protected TMessage ReadMessage<TMessage>() where TMessage : struct, IMessage
        {
            return ReadMessages<TMessage>().Single();
        }

        protected IEnumerable<(Guid, TComponent)> ReadComponents<TComponent>() where TComponent : struct, IComponent
        {
            if (!readTypes.Contains(typeof(ComponentMessage<TComponent>)))
            {
                throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", this.GetType().Name, typeof(TComponent).Name);
            }

            return ReadMessages<ComponentMessage<TComponent>>().Select((message) => (message.componentID, message.component));
        }

        protected (Guid, TComponent) ReadComponent<TComponent>() where TComponent : struct, IComponent
        {
            return ReadComponents<TComponent>().Single();
        }

        protected bool SomeMessage<TMessage>() where TMessage : struct, IMessage
        {
            if (!readTypes.Contains(typeof(TMessage)))
            {
                throw new IllegalReadException("Engine {0} tried to read undeclared Message {1}", GetType().Name, typeof(TMessage).Name);
            }

            return ReadMessages<TMessage>().Any();
        }

        protected bool SomeComponent<TComponent>() where TComponent : struct, IComponent
        {
            if (!readTypes.Contains(typeof(ComponentMessage<TComponent>)))
            {
                throw new IllegalReadException("Engine {0} tried to read undeclared Component {1}", GetType().Name, typeof(TComponent).Name);
            }

            return ReadMessages<ComponentMessage<TComponent>>().Any();
        }

        protected void Destroy(Guid entityID)
        {
            entityManager.MarkForDestroy(entityID);
        }

        protected void RemoveComponent(Guid componentID)
        {
            componentManager.MarkForRemoval(componentID);
        }
    }
}