Engine-Pong/Shared/Network/NetworkManager.cs

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

using Syntriax.Engine.Core;

namespace Syntriax.Engine.Network;

public class NetworkManager : UniverseObject, INetworkManager
{
    private INetworkCommunicator networkCommunicator = null!;

    private readonly Dictionary<Type, Dictionary<Type, List<DelegateData>>> clientListenerDelegates = [];
    private readonly Dictionary<Type, Dictionary<Type, List<DelegateData>>> serverListenerDelegates = [];

    private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> clientPacketListeners = [];
    private readonly Dictionary<Type, Dictionary<string, Event<string, object>>> serverPacketListeners = [];
    private readonly List<(Type packetType, Delegate callback)> delegates = [];

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

            var previousCommunicator = networkCommunicator;
            networkCommunicator = value;

            if (previousCommunicator is not null) UnsubscribeDelegates(networkCommunicator);
            if (networkCommunicator is not null) SubscribeDelegates(networkCommunicator);
        }
    }

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

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

    public NetworkManager()
    {
        CachePacketDelegates();
        CacheListenerDelegates();

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

    private void CacheListenerDelegates()
    {
        foreach (Type clientListenerClass in GetClassesImplementing(typeof(IPacketListenerClient<>)))
        {
            Dictionary<Type, List<DelegateData>> clientInterfaceListeners = [];
            clientListenerDelegates.Add(clientListenerClass, clientInterfaceListeners);
            foreach (Type clientListenerInterface in GetInterfacesImplementing(clientListenerClass, typeof(IPacketListenerClient<>)))
            {
                Type clientListenerParameterType = clientListenerInterface.GetGenericArguments().First();
                List<DelegateData> delegateDataList = clientListenerInterface.GetMethods().Where(m => m.Name == nameof(IPacketListenerClient<INetworkEntity>.OnClientPacketArrived)).Select(m => new DelegateData(clientListenerParameterType, m)).ToList();
                clientInterfaceListeners.Add(clientListenerParameterType, delegateDataList);
            }
        }

        foreach (Type serverListenerClass in GetClassesImplementing(typeof(IPacketListenerServer<>)))
        {
            Dictionary<Type, List<DelegateData>> serverInterfaceListeners = [];
            serverListenerDelegates.Add(serverListenerClass, serverInterfaceListeners);
            foreach (Type serverListenerInterface in GetInterfacesImplementing(serverListenerClass, typeof(IPacketListenerServer<>)))
            {
                Type serverListenerParameterType = serverListenerInterface.GetGenericArguments().First();
                List<DelegateData> delegateDataList = serverListenerInterface.GetMethods().Where(m => m.Name == nameof(IPacketListenerServer<INetworkEntity>.OnServerPacketArrived)).Select(m => new DelegateData(serverListenerParameterType, m)).ToList();
                serverInterfaceListeners.Add(serverListenerParameterType, delegateDataList);
            }
        }
    }

    private void CachePacketDelegates()
    {
        // Find network packets implementing INetworkPacket
        IEnumerable<Type> packetTypes = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes())
            .Where(t => typeof(INetworkPacket).IsAssignableFrom(t) && !t.IsInterface && !t.IsAbstract && !t.IsGenericType);

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

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

            Type genericDelegateType = typeof(Event<,>.EventHandler).MakeGenericType(typeof(string), packetType);
            Delegate genericPacketReceivedDelegate = Delegate.CreateDelegate(genericDelegateType, this, genericOnPacketArrivedMethod);

            delegates.Add((packetType, genericPacketReceivedDelegate));
        }
    }

    private void SubscribeDelegates(INetworkCommunicator networkCommunicator)
    {
        MethodInfo subscribeToPacketsMethod = typeof(INetworkCommunicator)
            .GetMethod(nameof(INetworkCommunicator.SubscribeToPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;

        foreach ((Type packetType, Delegate callback) in delegates)
        {
            MethodInfo genericSubscribeMethod = subscribeToPacketsMethod.MakeGenericMethod(packetType);

            genericSubscribeMethod.Invoke(networkCommunicator, [callback]);
        }
    }

    private void UnsubscribeDelegates(INetworkCommunicator networkCommunicator)
    {
        MethodInfo unsubscribeFromPacketsMethod = typeof(INetworkCommunicator)
            .GetMethod(nameof(INetworkCommunicator.UnsubscribeFromPackets), BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance)!;

        foreach ((Type packetType, Delegate callback) in delegates)
        {
            MethodInfo genericUnsubscribeMethod = unsubscribeFromPacketsMethod.MakeGenericMethod(packetType);

            genericUnsubscribeMethod.Invoke(networkCommunicator, [callback]);
        }
    }

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

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

    private void OnPacketReceived<T>(string senderClientId, T entityDataPacket)
    {
        Type packetType = typeof(T);

        if (entityDataPacket is IEntityNetworkPacket entityPacket)
        {
            if (networkCommunicator is INetworkCommunicatorClient)
                if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? clientListeners))
                    if (clientListeners.TryGetValue(entityPacket.EntityId, out Event<string, object>? clientListenerData))
                        clientListenerData.Invoke(senderClientId, entityDataPacket!);

            if (networkCommunicator is INetworkCommunicatorServer)
                if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? serverListeners))
                    if (serverListeners.TryGetValue(entityPacket.EntityId, out Event<string, object>? serverListenerData))
                        serverListenerData.Invoke(senderClientId, entityDataPacket!);

            return;
        }

        if (networkCommunicator is INetworkCommunicatorClient)
            if (clientPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? clientListeners))
                foreach ((string id, Event<string, object> clientListenerData) in clientListeners)
                    clientListenerData.Invoke(senderClientId, entityDataPacket!);

        if (networkCommunicator is INetworkCommunicatorServer)
            if (serverPacketListeners.TryGetValue(packetType, out Dictionary<string, Event<string, object>>? serverListeners))
                foreach ((string id, Event<string, object> serverListenerData) in serverListeners)
                    serverListenerData.Invoke(senderClientId, entityDataPacket!);
    }

    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)}");

        if (clientListenerDelegates.TryGetValue(collectedBehaviour.GetType(), out Dictionary<Type, List<DelegateData>>? clientInterfaceDelegates))
            foreach ((Type clientListenerInterfaceType, List<DelegateData> clientDelegateDataList) in clientInterfaceDelegates)
                foreach ((Type parameterType, MethodInfo receiveMethod) in clientDelegateDataList)
                {
                    if (!clientPacketListeners.TryGetValue(parameterType, out Dictionary<string, Event<string, object>>? clientListeners))
                    {
                        clientListeners = [];
                        clientPacketListeners.Add(parameterType, clientListeners);
                    }

                    Event<string, object> clientListenerEvent = new();
                    clientListenerEvent.AddListener((sender, @object) => receiveMethod.Invoke(collectedBehaviour, [@object]));
                    clientListeners.Add(collectedBehaviour.Id, clientListenerEvent);
                }

        if (serverListenerDelegates.TryGetValue(collectedBehaviour.GetType(), out Dictionary<Type, List<DelegateData>>? serverInterfaceDelegates))
            foreach ((Type serverListenerInterfaceType, List<DelegateData> serverDelegateDataList) in serverInterfaceDelegates)
                foreach ((Type parameterType, MethodInfo receiveMethod) in serverDelegateDataList)
                {
                    if (!serverPacketListeners.TryGetValue(parameterType, out Dictionary<string, Event<string, object>>? serverListeners))
                    {
                        serverListeners = [];
                        serverPacketListeners.Add(parameterType, serverListeners);
                    }

                    Event<string, object> serverListenerEvent = new();
                    serverListenerEvent.AddListener((sender, @object) => receiveMethod.Invoke(collectedBehaviour, [sender, @object]));
                    serverListeners.Add(collectedBehaviour.Id, serverListenerEvent);
                }
    }

    private void OnRemoved(IBehaviourCollector<INetworkEntity> sender, IBehaviourCollector<INetworkEntity>.BehaviourRemovedArguments args)
    {
        _networkEntities.Remove(args.BehaviourRemoved.Id);
    }

    protected override void OnExitingUniverse(IUniverse universe) => _networkEntityCollector.Unassign();
    protected override void OnEnteringUniverse(IUniverse universe)
    {
        _networkEntityCollector.Assign(universe);
        NetworkCommunicator = this.GetRequiredUniverseObjectInParent<INetworkCommunicator>();
    }

    private record struct DelegateData(Type ParameterType, MethodInfo ReceiveMethod)
    {
        public static implicit operator (Type ParameterType, MethodInfo ReceiveMethod)(DelegateData value) => (value.ParameterType, value.ReceiveMethod);
        public static implicit operator DelegateData((Type ParameterType, MethodInfo ReceiveMethod) value) => new(value.ParameterType, value.ReceiveMethod);
    }
}