ResourceManager.cs

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using Newtonsoft.Json.Linq;
using Raylib_cs;

namespace TipeEngine
{
    public static class ResourceManager
    {
        private static readonly Dictionary<string, object> loadedObjects = [];
        private static readonly Dictionary<string, ComponentContext> ComponentCache = [];

        private static readonly Dictionary<Type, Func<string, object>> CustomDeserializers = new()
        {
            { typeof(Texture2D), static path => LoadTexture(path) },
            { typeof(Image), static path => LoadImage(path) },
            { typeof(Sound), static path => LoadSound(path) },
            { typeof(GameObject), static _ => throw new NotSupportedException($"can't deserialize a nested GameObject") }
        };

        internal static void CacheComponents()
        {
            foreach (Type type in AppDomain.CurrentDomain.GetAssemblies()
                .SelectMany(static a => a.GetTypes())
                .Where(static t => typeof(IComponent).IsAssignableFrom(t)))
            {
                string name = type.FullName ?? throw new UnreachableException("some how.... a type has no name...");

                ConstructorInfo[] constructors = type.GetConstructors(BindingFlags.Public | BindingFlags.Instance);

                if (constructors.Length == 0)
                {
                    continue;
                }

                ConstructorInfo constructor =
                    constructors.FirstOrDefault(static c => Attribute.IsDefined(c, typeof(PreferredConstructorAttribute))) ??
                    constructors.FirstOrDefault() ??
                    throw new UnreachableException("There are more than 0 contstructors yet it failed to get the first one");

                ParameterInfo[] parameters = constructor.GetParameters();

                ComponentContext context = new(type, constructor);
                ComponentCache[name] = context;
            }
        }

        public static T LoadGameObject<T>(string path, string variant = "") where T : GameObject
        {
            return (T)LoadGameObject(path, typeof(T), variant);
        }

        public static object LoadGameObject(string path, Type type, string variant = "")
        {
            path += string.IsNullOrEmpty(variant) ? $"{type.Name}.json" : $"{type.Name}_{variant}.json";
            string json = File.ReadAllText(path);
            JObject root = JObject.Parse(json);

            JToken objectToken = root["object"] ??
                throw new SerializationException($"Could not find `object` in `{path}`");

            object? gameObjectRaw = objectToken.ToObject(type);
            if (gameObjectRaw is not GameObject gameObject)
            {
                throw new SerializationException($"Failed to deserialize `object` from `{path}`");
            }

            JToken? componentsToken = root["components"];
            if (componentsToken == null)
            {
                return gameObject;
            }

            if (componentsToken is JArray componentsArray)
            {
                foreach (JToken componentToken in componentsArray)
                {
                    if (componentToken is not JObject componentObject)
                    {
                        continue;
                    }

                    IComponent component = LoadComponent(componentObject, gameObject);
                    _ = gameObject.AddComponent(component);
                }
            }

            return gameObject;
        }

        private static IComponent LoadComponent(JObject componentObject, GameObject? baseObject = null)
        {
            string componentTypeName = componentObject["type"]?.ToString() ??
                throw new SerializationException("failed to get component type");

            if (!ComponentCache.TryGetValue(componentTypeName, out ComponentContext componentContext))
            {
                throw new SerializationException($"can't find component context of `{componentTypeName}`");
            }

            ConstructorInfo constructor = componentContext.constructor;
            ParameterInfo[] parameters = componentContext.parameters;
            List<object> parameterList = [];
            foreach (ParameterInfo parameter in parameters)
            {
                Type parameterType = parameter.ParameterType;
                string parameterName = parameter.Name!;
                JToken parameterToken = componentObject[parameterName] ??
                    throw new SerializationException($"no `{parameterName}` on component `{componentTypeName}`");
                object parameterObject = parameterType.IsGenericType
                    ? parameterToken.ToObject(parameterType) ??
                        throw new SerializationException($"failed to deserialize `{parameterName}` from `{componentTypeName}`")
                    : ResolveParameter(parameterType, parameterToken, baseObject, parameterName, componentTypeName);
                parameterList.Add(parameterObject);
            }

            return (IComponent)constructor.Invoke([.. parameterList]);
        }

        private static object ResolveParameter(Type parameterType, JToken token, GameObject? baseObject, string paramName, string componentName)
        {
            string value = token.ToObject<string>() ??
                throw new SerializationException($"failed to deserialize `{paramName}`");

            return parameterType == typeof(GameObject) && value == "base"
                ? baseObject ?? throw new ArgumentNullException(nameof(baseObject), "Base object was not provided.")
                : CustomDeserializers.TryGetValue(parameterType, out Func<string, object>? loader)
                ? loader(value)
                : throw new SerializationException($"Unhandled type {parameterType} in `{componentName}`");
        }

        private static Sound LoadSound(string path)
        {
            return LoadWithCache(path, Raylib.LoadSound);
        }

        private static Image LoadImage(string path)
        {
            return LoadWithCache(path, Raylib.LoadImage);
        }

        private static Texture2D LoadTexture(string path)
        {
            return LoadWithCache(path, Raylib.LoadTexture);
        }

        private static T LoadWithCache<T>(string path, Func<string, T> loader)
        {
            if (loadedObjects.TryGetValue(path, out object? cache) && cache is T t)
            {
                return t;
            }
            T result = loader(path);
            loadedObjects[path] = result!;
            return result;
        }

        public static void ClearObjects()
        {
            foreach (object loadedObject in loadedObjects.Values)
            {
                if (loadedObject is Sound sound)
                {
                    Raylib.UnloadSound(sound);
                }
                else if (loadedObject is Image image)
                {
                    Raylib.UnloadImage(image);
                }
                else if (loadedObject is Texture2D texture)
                {
                    Raylib.UnloadTexture(texture);
                }
            }

            loadedObjects.Clear();
        }
    }

    public readonly struct ComponentContext
    {
        public readonly Type type { get; }
        public readonly ConstructorInfo constructor { get; }
        public readonly ParameterInfo[] parameters { get; }

        public ComponentContext(Type _type, ConstructorInfo _constructor)
        {
            type = _type;
            constructor = _constructor;
            parameters = constructor.GetParameters();
        }
    }

    [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)]
    public class PreferredConstructorAttribute : Attribute
    {
        public PreferredConstructorAttribute() { }
    }
}