using System;
using System.Collections.Generic;
using System.Linq;

namespace Encompass
{
    internal class ComponentUpdateManager
    {
        private readonly ComponentStore existingComponentStore;
        private readonly ComponentStore immediateComponentStore;
        private readonly ComponentStore existingAndImmediateComponentStore;
        public ComponentStore UpToDateComponentStore { get; private set; }

        public Dictionary<Type, int> TypeToIndex { get; }

        public ComponentUpdateManager(Dictionary<Type, int> typeToIndex)
        {
            existingAndImmediateComponentStore = new ComponentStore(typeToIndex);
            existingComponentStore = new ComponentStore(typeToIndex);
            immediateComponentStore = new ComponentStore(typeToIndex);
            UpToDateComponentStore = new ComponentStore(typeToIndex);
            TypeToIndex = typeToIndex;
        }

        public void RegisterComponentType<TComponent>() where TComponent : struct, IComponent
        {
            existingAndImmediateComponentStore.RegisterComponentType<TComponent>();
            existingComponentStore.RegisterComponentType<TComponent>();
            immediateComponentStore.RegisterComponentType<TComponent>();
            UpToDateComponentStore.RegisterComponentType<TComponent>();
        }

        internal void Clear()
        {
            existingAndImmediateComponentStore.ClearAll();
            existingComponentStore.ClearAll();
            immediateComponentStore.ClearAll();
            UpToDateComponentStore.ClearAll();
        }

        internal void SetStartingComponentStore(ComponentStore componentStore)
        {
            UpToDateComponentStore = componentStore;
        }

        internal void AddExistingComponent<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent
        {
            RegisterExistingOrImmediateComponentMessage(entity, component);

            existingComponentStore.Set(entity.ID, component);
        }

        internal bool AddImmediateComponent<TComponent>(Entity entity, TComponent component, int priority) where TComponent : struct, IComponent
        {
            if (immediateComponentStore.Set(entity.ID, component, priority))
            {
                RegisterExistingOrImmediateComponentMessage(entity, component);
                return true;
            }

            return false;
        }

        internal bool RemoveImmediate<TComponent>(Entity entity, int priority) where TComponent : struct, IComponent
        {
            if (immediateComponentStore.Remove<TComponent>(entity.ID, priority))
            {
                existingAndImmediateComponentStore.Remove<TComponent>(entity.ID, priority);
                UpToDateComponentStore.Remove<TComponent>(entity.ID, priority);
                return true;
            }

            return false;
        }

        internal bool Remove<TComponent>(Entity entity, int priority) where TComponent : struct, IComponent
        {
            if (existingComponentStore.Remove<TComponent>(entity.ID, priority))
            {
                UpToDateComponentStore.Remove<TComponent>(entity.ID, priority);
                return true;
            }

            return false;
        }

        private void RegisterExistingOrImmediateComponentMessage<TComponent>(Entity entity, TComponent component) where TComponent : struct, IComponent
        {
            existingAndImmediateComponentStore.Set(entity.ID, component);
            UpToDateComponentStore.Set(entity.ID, component);
        }

        public bool UpdateComponent<TComponent>(Entity entity, TComponent component, int priority) where TComponent : struct, IComponent
        {
            return UpToDateComponentStore.Set<TComponent>(entity.ID, component, priority);
        }

        // general component reads by type

        internal IEnumerable<(TComponent, int)> ReadExistingAndImmediateComponentsByType<TComponent>() where TComponent : struct, IComponent
        {
            return existingAndImmediateComponentStore.All<TComponent>();
        }

        internal IEnumerable<(TComponent, int)> ReadExistingComponentsByType<TComponent>() where TComponent : struct, IComponent
        {
            return existingComponentStore.All<TComponent>();
        }

        internal IEnumerable<(TComponent, int)> ReadImmediateComponentsByType<TComponent>() where TComponent : struct, IComponent
        {
            return immediateComponentStore.All<TComponent>();
        }

        // singular component reads by type

        internal (TComponent, int) ReadFirstExistingOrImmediateComponentByType<TComponent>() where TComponent : struct, IComponent
        {
            if (!SomeExistingOrImmediateComponent<TComponent>()) { throw new Exceptions.NoComponentOfTypeException($"No Component with type {typeof(TComponent)} exists"); }
            var enumerator = ReadExistingAndImmediateComponentsByType<TComponent>().GetEnumerator();
            enumerator.MoveNext();
            return enumerator.Current;
        }

        internal (TComponent, int) ReadFirstExistingComponentByType<TComponent>() where TComponent : struct, IComponent
        {
            if (!SomeExistingComponent<TComponent>()) { throw new Exceptions.NoComponentOfTypeException($"No Component with type {typeof(TComponent)} exists"); }
            var enumerator = ReadExistingComponentsByType<TComponent>().GetEnumerator();
            enumerator.MoveNext();
            return enumerator.Current;
        }

        internal (TComponent, int) ReadFirstImmediateComponentByType<TComponent>() where TComponent : struct, IComponent
        {
            if (!SomeImmediateComponent<TComponent>()) { throw new Exceptions.NoComponentOfTypeException($"No Component with type {typeof(TComponent)} exists"); }
            var enumerator = ReadImmediateComponentsByType<TComponent>().GetEnumerator();
            enumerator.MoveNext();
            return enumerator.Current;
        }

        // check if some component of type exists in the world

        internal bool SomeExistingOrImmediateComponent<TComponent>() where TComponent : struct, IComponent
        {
            return existingAndImmediateComponentStore.Any<TComponent>();
        }

        internal bool SomeExistingComponent<TComponent>() where TComponent : struct, IComponent
        {
            return existingComponentStore.Any<TComponent>();
        }

        internal bool SomeImmediateComponent<TComponent>() where TComponent : struct, IComponent
        {
            return immediateComponentStore.Any<TComponent>();
        }

        // read components by entity and type

        internal TComponent ReadExistingComponentByEntityAndType<TComponent>(Entity entity) where TComponent : struct, IComponent
        {
            return existingComponentStore.Get<TComponent>(entity.ID);
        }

        internal TComponent ReadImmediateComponentByEntityAndType<TComponent>(Entity entity) where TComponent : struct, IComponent
        {
            return immediateComponentStore.Get<TComponent>(entity.ID);
        }

        // check if entity has component of type

        internal bool HasExistingOrImmediateComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
        {
            return existingAndImmediateComponentStore.Has<TComponent>(entity.ID);
        }

        internal bool HasExistingOrImmediateComponent(Entity entity, Type type)
        {
            return existingAndImmediateComponentStore.Has(type, entity.ID);
        }

        internal bool HasExistingComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
        {
            return existingComponentStore.Has<TComponent>(entity.ID);
        }

        internal bool HasExistingComponent(Entity entity, Type type)
        {
            return existingComponentStore.Has(type, entity.ID);
        }

        internal bool HasImmediateComponent<TComponent>(Entity entity) where TComponent : struct, IComponent
        {
            return immediateComponentStore.Has<TComponent>(entity.ID);
        }

        internal bool HasImmediateComponent(Entity entity, Type type)
        {
            return immediateComponentStore.Has(type, entity.ID);
        }

        internal ComponentBitSet ImmediateBits { get { return immediateComponentStore.ComponentBitSet; } }
        internal ComponentBitSet ExistingBits { get { return existingComponentStore.ComponentBitSet; } }
    }
}