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

namespace Encompass
{
    internal class DrawLayerManager
    {
        private readonly SortedList<int, int> layerOrder = new SortedList<int, int>();

        private readonly Dictionary<int, ComponentStore> layerIndexToComponentStore = new Dictionary<int, ComponentStore>();
        private readonly Dictionary<int, HashSet<GeneralRenderer>> layerIndexToGeneralRenderers = new Dictionary<int, HashSet<GeneralRenderer>>();

        private readonly Dictionary<Type, Dictionary<Entity, int>> typeToEntityToLayer = new Dictionary<Type, Dictionary<Entity, int>>();

        public IEnumerable<int> LayerOrder { get { return layerOrder.Values; } }

        public void RegisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
        {
            if (layerIndexToGeneralRenderers.ContainsKey(layer))
            {
                var set = layerIndexToGeneralRenderers[layer];
                set.Add(renderer);
            }
            else
            {
                var set = new HashSet<GeneralRenderer>();
                layerIndexToGeneralRenderers.Add(layer, set);
                set.Add(renderer);
            }

            if (!layerOrder.ContainsKey(layer))
            {
                layerOrder.Add(layer, layer);
            }
        }

        public void UnregisterGeneralRendererWithLayer(GeneralRenderer renderer, int layer)
        {
            if (layerIndexToGeneralRenderers.ContainsKey(layer))
            {
                layerIndexToGeneralRenderers[layer].Remove(renderer);
            }
        }

        public void AdjustRendererLayer(GeneralRenderer renderer, int oldLayer, int newLayer)
        {
            UnregisterGeneralRendererWithLayer(renderer, oldLayer);
            RegisterGeneralRendererWithLayer(renderer, newLayer);
        }

        public void RegisterComponentWithLayer<TComponent>(Entity entity, TComponent component, int layer) where TComponent : struct, IComponent
        {
            if (!typeToEntityToLayer.ContainsKey(typeof(TComponent)))
            {
                typeToEntityToLayer.Add(typeof(TComponent), new Dictionary<Entity, int>());
            }

            if (typeToEntityToLayer[typeof(TComponent)].ContainsKey(entity)) { UnRegisterComponentWithLayer<TComponent>(entity); }

            if (layerIndexToComponentStore.ContainsKey(layer))
            {
                var set = layerIndexToComponentStore[layer];
                set.Set<TComponent>(entity, component);
            }
            else
            {
                var set = new ComponentStore();
                layerIndexToComponentStore.Add(layer, set);
                set.Set<TComponent>(entity, component);
            }

            typeToEntityToLayer[typeof(TComponent)].Add(entity, layer);

            if (!layerOrder.ContainsKey(layer))
            {
                layerOrder.Add(layer, layer);
            }
        }

        public void UnRegisterComponentWithLayer<TComponent>(Entity entity) where TComponent : struct, IComponent
        {
            if (!typeToEntityToLayer.ContainsKey(typeof(TComponent))) { return; }

            if (typeToEntityToLayer[typeof(TComponent)].ContainsKey(entity))
            {
                var layer = typeToEntityToLayer[typeof(TComponent)][entity];
                layerIndexToComponentStore[layer].Remove<TComponent>(entity);
            }
            typeToEntityToLayer[typeof(TComponent)].Remove(entity);
        }

        public void UnRegisterEntityWithLayer(Entity entity)
        {
            foreach (var store in layerIndexToComponentStore.Values)
            {
                store.Remove(entity);
            }
        }

        public IEnumerable<GeneralRenderer> GeneralRenderersByLayer(int layer)
        {
            return layerIndexToGeneralRenderers.ContainsKey(layer) ?
                layerIndexToGeneralRenderers[layer] :
                Enumerable.Empty<GeneralRenderer>();
        }

        public IEnumerable<(Entity, Type, IComponent)> AllInLayer(int layer)
        {
            return layerIndexToComponentStore.ContainsKey(layer) ?
                layerIndexToComponentStore[layer].AllInterfaceTyped() :
                Enumerable.Empty<(Entity, Type, IComponent)>();
        }
    }
}