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

using Engine.Core;

namespace Engine.Systems.Network;

/// <summary>
/// Intermediary manager that looks up in it's hierarchy for a <see cref="INetworkCommunicator"/> to route/broadcast it's received packets to their destinations.
/// </summary>
/// TODO: I urgently need to add proper comments on this manager, I don't exactly remember the state I was in when I was writing it.
/// It's a fairly complex manager that relies heavily on Reflection and lots of generic method delegation which is making it very hard to read back. 
public class NetworkManager : Behaviour, IEnterUniverse, IExitUniverse, INetworkManager
{
    private readonly Dictionary<Type, Dictionary<Type, List<MethodInfo>>> clientBroadcastPacketArrivalMethods = [];
    private readonly Dictionary<Type, Dictionary<Type, List<MethodInfo>>> serverBroadcastPacketArrivalMethods = [];

    private readonly Dictionary<Type, Dictionary<string, object>> clientBroadcastPacketRouters = [];
    private readonly Dictionary<Type, Dictionary<string, object>> serverBroadcastPacketRouters = [];

    private readonly Dictionary<Type, Dictionary<Type, List<MethodInfo>>> clientEntityPacketArrivalMethods = [];
    private readonly Dictionary<Type, Dictionary<Type, List<MethodInfo>>> serverEntityPacketArrivalMethods = [];

    private readonly Dictionary<Type, Dictionary<string, object>> clientEntityPacketRouters = [];
    private readonly Dictionary<Type, Dictionary<string, object>> serverEntityPacketRouters = [];

    private readonly List<(Type packetType, Delegate @delegate)> broadcastPacketRetrievalDelegates = [];
    private readonly List<(Type packetType, Delegate @delegate)> entityPacketRetrievalDelegates = [];

    private readonly Dictionary<Type, MethodInfo> clearRoutesMethods = [];
    private readonly Dictionary<Type, MethodInfo> registerBroadcastPacketListenersMethods = [];
    private readonly Dictionary<Type, MethodInfo> registerEntityPacketListenersMethods = [];

    private readonly Dictionary<string, INetworkEntity> _networkEntities = [];
    public IReadOnlyDictionary<string, INetworkEntity> NetworkEntities => _networkEntities;

    private readonly BehaviourCollector<INetworkEntity> _networkEntityCollector = new();
    public IBehaviourCollector<INetworkEntity> NetworkEntityCollector => _networkEntityCollector;

    public INetworkCommunicator NetworkCommunicator
    {
        get;
        set
        {
            if (field == value)
                return;

            INetworkCommunicator? previousCommunicator = field;
            field = value;

            if (previousCommunicator is not null) InvokeCommunicatorMethods(previousCommunicator, nameof(INetworkCommunicator.UnsubscribeFromPackets));
            if (field is not null) InvokeCommunicatorMethods(field, nameof(INetworkCommunicator.SubscribeToPackets));
        }
    } = null!;

    /// Used to delegate subscription and unsubscription methods on the <see cref="INetworkCommunicator"/> to <see cref="OnPacketReceived{T}(IConnection, T)"/>.
    private void InvokeCommunicatorMethods(INetworkCommunicator networkCommunicator, string name)
    {
        MethodInfo unsubscribeFromPacketsMethod = typeof(INetworkCommunicator)
            .GetMethod(name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;

        /// Get unique entries by the packetType so we don't get duplicate calls to <see cref="OnPacketReceived{T}(IConnection, T)"/>
        /// Because a class might have both <see cref="IPacketListenerClient{T}"/> and <see cref="IPacketListenerClientEntity{T}"/>
        /// or <see cref="IPacketListenerServer{T}"/> and <see cref="IPacketListenerServerEntity{T}"/> together.
        IEnumerable<(Type packetType, Delegate @delegate)> distinctRetrievalSubscriptionDelegates =
            broadcastPacketRetrievalDelegates.Concat(entityPacketRetrievalDelegates).DistinctBy(pair => pair.packetType);

        foreach ((Type packetType, Delegate @delegate) in distinctRetrievalSubscriptionDelegates)
        {
            MethodInfo genericMethod = unsubscribeFromPacketsMethod.MakeGenericMethod(packetType);
            genericMethod.Invoke(networkCommunicator, [@delegate]);
        }
    }

    #region Packet Routing/Broadcasting
    private void OnPacketReceived<T>(IConnection sender, T entityDataPacket)
    {
        BroadcastPacket(sender, entityDataPacket);
        if (entityDataPacket is IEntityNetworkPacket entityPacket)
            RoutePacket(sender, entityDataPacket, entityPacket);
    }

    private void RoutePacket<T>(IConnection sender, T entityDataPacket, IEntityNetworkPacket entityPacket)
    {
        if (NetworkCommunicator is INetworkCommunicatorClient)
            RoutePacket(clientEntityPacketRouters, entityPacket.EntityId, sender, entityDataPacket);
        if (NetworkCommunicator is INetworkCommunicatorServer)
            RoutePacket(serverEntityPacketRouters, entityPacket.EntityId, sender, entityDataPacket);
    }

    private void BroadcastPacket<T>(IConnection sender, T entityDataPacket)
    {
        if (NetworkCommunicator is INetworkCommunicatorClient)
            BroadcastPacket(clientBroadcastPacketRouters, sender, entityDataPacket);
        if (NetworkCommunicator is INetworkCommunicatorServer)
            BroadcastPacket(serverBroadcastPacketRouters, sender, entityDataPacket);
    }

    private void BroadcastPacket<T>(
        Dictionary<Type, Dictionary<string, object>> packetRouters,
        IConnection sender,
        T entityDataPacket)
    {
        if (!packetRouters.TryGetValue(entityDataPacket!.GetType(), out Dictionary<string, object>? routers))
            return;

        foreach ((string behaviourId, object routerEventReference) in routers)
        {
            Event<IConnection, T> routerEvent = (Event<IConnection, T>)routerEventReference;
            routerEvent.Invoke(sender, entityDataPacket!);
        }
    }

    private void RoutePacket<T>(
        Dictionary<Type, Dictionary<string, object>> packetRouters,
        string entityId,
        IConnection sender,
        T entityDataPacket)
    {
        if (!packetRouters.TryGetValue(entityDataPacket!.GetType(), out Dictionary<string, object>? routers))
            return;

        if (!routers.TryGetValue(entityId, out object? routerEventReference))
            return;

        Event<IConnection, T> routerEvent = (Event<IConnection, T>)routerEventReference;
        routerEvent.Invoke(sender, entityDataPacket!);
    }
    #endregion

    #region Packet Routers
    private void RegisterPacketRoutersFor(
        INetworkEntity behaviour,
        Dictionary<Type, Dictionary<string, object>> packetRouters,
        Dictionary<Type, Dictionary<Type, List<MethodInfo>>> packetArrivalMethods,
        NetworkType networkType, Dictionary<Type, MethodInfo> registerPacketListenersMethods)
    {
        if (!packetArrivalMethods.TryGetValue(behaviour.GetType(), out Dictionary<Type, List<MethodInfo>>? arrivalMethods))
            return;

        foreach (Type packetType in arrivalMethods.Keys)
        {
            if (!packetRouters.TryGetValue(packetType, out Dictionary<string, object>? routers))
            {
                routers = [];
                packetRouters.Add(packetType, routers);
            }

            object packetListenerEvent =
                CreateEventAndRegister(packetType, behaviour, networkType, registerPacketListenersMethods);

            routers.Add(behaviour.Id, packetListenerEvent);
        }
    }

    private object CreateEventAndRegister(Type packetType, INetworkEntity behaviour, NetworkType networkType, Dictionary<Type, MethodInfo> registerPacketListenersMethods)
    {
        Type genericEventType = typeof(Event<,>).MakeGenericType(typeof(IConnection), packetType);
        object packetListenerEvent = Activator.CreateInstance(genericEventType)!;

        if (!registerPacketListenersMethods.TryGetValue(packetType, out MethodInfo? registerPacketListenerMethod))
            throw new($"Packet Listener Events for {packetType.Name} has not been cached.");

        registerPacketListenerMethod.Invoke(this, [behaviour, packetListenerEvent, networkType]);
        return packetListenerEvent;
    }

    private static void RegisterPacketListenerEvent<T>(
        INetworkEntity behaviour,
        Event<IConnection, T> packetListenerEvent,
        NetworkType networkType)
    {
        switch (networkType)
        {
            case NetworkType.Client: packetListenerEvent.AddListener((sender, packet) => ((IPacketListenerClient<T>)behaviour).OnClientPacketArrived(sender, packet)); break;
            case NetworkType.Server: packetListenerEvent.AddListener((sender, packet) => ((IPacketListenerServer<T>)behaviour).OnServerPacketArrived(sender, packet)); break;
        }
    }

    private static void RegisterEntityPacketListenerEvent<T>(
        INetworkEntity behaviour,
        Event<IConnection, T> packetListenerEvent,
        NetworkType networkType
    ) where T : IEntityNetworkPacket
    {
        switch (networkType)
        {
            case NetworkType.Client: packetListenerEvent.AddListener((sender, packet) => ((IPacketListenerClientEntity<T>)behaviour).OnEntityClientPacketArrived(sender, packet)); break;
            case NetworkType.Server: packetListenerEvent.AddListener((sender, packet) => ((IPacketListenerServerEntity<T>)behaviour).OnEntityServerPacketArrived(sender, packet)); break;
        }
    }

    private void UnregisterPacketRoutersFor(
        INetworkEntity behaviour,
        Dictionary<Type, Dictionary<string, object>> packetRouters,
        Dictionary<Type, Dictionary<Type, List<MethodInfo>>> packetArrivalMethods)
    {
        if (!packetArrivalMethods.TryGetValue(behaviour.GetType(), out Dictionary<Type, List<MethodInfo>>? arrivalMethods))
            return;

        foreach ((Type packetType, List<MethodInfo> methods) in arrivalMethods)
        {
            if (!packetRouters.TryGetValue(packetType, out Dictionary<string, object>? routers))
                continue;

            if (!routers.TryGetValue(behaviour.Id, out object? routerEventReference))
                continue;

            if (!clearRoutesMethods.TryGetValue(packetType, out MethodInfo? clearRouterMethod))
                continue;

            clearRouterMethod.Invoke(this, [routerEventReference]);
        }
    }

    private static void ClearRouter<T>(object routerEventReference)
    {
        Event<IConnection, T> routerEvent = (Event<IConnection, T>)routerEventReference;
        routerEvent.Clear();
    }

    #endregion

    #region Engine Callbacks
    private void OnCollected(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourCollectedArguments args)
    {
        INetworkEntity collectedBehaviour = args.BehaviourCollected;

        if (!_networkEntities.TryAdd(collectedBehaviour.Id, collectedBehaviour))
            throw new($"Unable to add {collectedBehaviour.Id} to {nameof(NetworkManager)}");

        RegisterPacketRoutersFor(collectedBehaviour, clientBroadcastPacketRouters, clientBroadcastPacketArrivalMethods, NetworkType.Client, registerBroadcastPacketListenersMethods);
        RegisterPacketRoutersFor(collectedBehaviour, clientEntityPacketRouters, clientEntityPacketArrivalMethods, NetworkType.Client, registerEntityPacketListenersMethods);

        RegisterPacketRoutersFor(collectedBehaviour, serverBroadcastPacketRouters, serverBroadcastPacketArrivalMethods, NetworkType.Server, registerBroadcastPacketListenersMethods);
        RegisterPacketRoutersFor(collectedBehaviour, serverEntityPacketRouters, serverEntityPacketArrivalMethods, NetworkType.Server, registerEntityPacketListenersMethods);
    }

    private void OnRemoved(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourRemovedArguments args)
    {
        INetworkEntity removedBehaviour = args.BehaviourRemoved;
        if (!_networkEntities.Remove(args.BehaviourRemoved.Id))
            return;

        UnregisterPacketRoutersFor(removedBehaviour, clientBroadcastPacketRouters, clientBroadcastPacketArrivalMethods);
        UnregisterPacketRoutersFor(removedBehaviour, clientEntityPacketRouters, clientEntityPacketArrivalMethods);

        UnregisterPacketRoutersFor(removedBehaviour, serverBroadcastPacketRouters, serverBroadcastPacketArrivalMethods);
        UnregisterPacketRoutersFor(removedBehaviour, serverEntityPacketRouters, serverEntityPacketArrivalMethods);
    }

    public void ExitUniverse(IUniverse universe) => _networkEntityCollector.Unassign();
    public void EnterUniverse(IUniverse universe)
    {
        _networkEntityCollector.Assign(universe);
        NetworkCommunicator = BehaviourController.GetRequiredBehaviourInParent<INetworkCommunicator>();
    }
    #endregion

    #region Initialization
    public NetworkManager()
    {
        CachePacketRetrievalDelegates(typeof(INetworkPacket), broadcastPacketRetrievalDelegates);
        CachePacketRetrievalDelegates(typeof(IEntityNetworkPacket), entityPacketRetrievalDelegates);
        CacheRegistrationMethods();
        CachePacketArrivalMethods();

        _networkEntityCollector.OnCollected.AddListener(OnCollected);
        _networkEntityCollector.OnRemoved.AddListener(OnRemoved);
    }

    private void CachePacketRetrievalDelegates(Type packetType, List<(Type packetType, Delegate @delegate)> retrievalDelegates)
    {
        IEnumerable<Type> packetTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes())
            .Where(t => packetType.IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract && !t.IsGenericType);

        MethodInfo onPacketArrivedMethod = GetType()
            .GetMethod(nameof(OnPacketReceived), BindingFlags.NonPublic | BindingFlags.Instance)!;

        foreach (Type pType in packetTypes)
        {
            MethodInfo genericOnPacketArrivedMethod = onPacketArrivedMethod.MakeGenericMethod(pType);

            Type genericDelegateType = typeof(Event<,>.EventHandler).MakeGenericType(typeof(IConnection), pType);
            Delegate genericPacketReceivedDelegate = Delegate.CreateDelegate(genericDelegateType, this, genericOnPacketArrivedMethod);
            retrievalDelegates.Add((pType, genericPacketReceivedDelegate));
        }
    }

    private void CacheRegistrationMethods()
    {
        CacheRegistrationMethods(registerBroadcastPacketListenersMethods, nameof(RegisterPacketListenerEvent), broadcastPacketRetrievalDelegates);
        CacheRegistrationMethods(registerEntityPacketListenersMethods, nameof(RegisterEntityPacketListenerEvent), entityPacketRetrievalDelegates);
        CacheRegistrationMethods(clearRoutesMethods, nameof(ClearRouter), broadcastPacketRetrievalDelegates);
    }

    private void CacheRegistrationMethods(Dictionary<Type, MethodInfo> registrationMethods, string methodName, List<(Type packetType, Delegate @delegate)> packetRetrievalDelegates)
    {
        MethodInfo registerPacketMethod = typeof(NetworkManager).GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Static)!;
        foreach ((Type packetType, Delegate @delegate) in packetRetrievalDelegates)
        {
            MethodInfo genericMethod = registerPacketMethod.MakeGenericMethod(packetType);
            registrationMethods.TryAdd(packetType, genericMethod);
        }
    }

    private void CachePacketArrivalMethods()
    {
        CachePacketArrivalMethods(clientBroadcastPacketArrivalMethods, typeof(IPacketListenerClient<>), nameof(IPacketListenerClient<>.OnClientPacketArrived));
        CachePacketArrivalMethods(serverBroadcastPacketArrivalMethods, typeof(IPacketListenerServer<>), nameof(IPacketListenerServer<>.OnServerPacketArrived));
        CachePacketArrivalMethods(clientEntityPacketArrivalMethods, typeof(IPacketListenerClientEntity<>), nameof(IPacketListenerClientEntity<>.OnEntityClientPacketArrived));
        CachePacketArrivalMethods(serverEntityPacketArrivalMethods, typeof(IPacketListenerServerEntity<>), nameof(IPacketListenerServerEntity<>.OnEntityServerPacketArrived));
    }

    private static void CachePacketArrivalMethods(Dictionary<Type, Dictionary<Type, List<MethodInfo>>> packetArrivalMethods, Type listenerType, string packetArrivalMethodName)
    {
        foreach (Type listenerClass in GetGenericsWith(listenerType))
        {
            Dictionary<Type, List<MethodInfo>> packetRouters = [];
            packetArrivalMethods.Add(listenerClass, packetRouters);

            foreach (Type packetListener in GetGenericInterfacesWith(listenerType, listenerClass))
            {
                Type packetType = packetListener.GetGenericArguments().First();

                List<MethodInfo> arrivalMethods = packetListener
                    .GetMethods()
                    .Where(m => m.Name == packetArrivalMethodName)
                    .ToList();

                packetRouters.Add(packetType, arrivalMethods);
            }
        }
    }

    private static IEnumerable<Type> GetGenericsWith(Type type)
        => AppDomain.CurrentDomain
            .GetAssemblies()
            .SelectMany(a =>
                a.GetTypes().Where(
                    t => t.GetInterfaces().Any(
                        i => i.IsGenericType && i.GetGenericTypeDefinition() == type
                    )
                )
            );

    private static IEnumerable<Type> GetGenericInterfacesWith(Type interfaceType, Type type)
        => type.GetInterfaces().Where(
            i => i.IsGenericType && i.GetGenericTypeDefinition() == interfaceType
        );
    #endregion

    private enum NetworkType { Client, Server }
}