MinecraftConsoles/Minecraft.Server.FourKit/PluginLoader.cs

using Minecraft.Server.FourKit.Plugin;
using System.Reflection;

namespace Minecraft.Server.FourKit;

internal sealed class PluginLoader
{
    private static readonly BindingFlags DeclaredPublic =
        BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;

    private readonly List<ServerPlugin> _plugins = new();

    public IReadOnlyList<ServerPlugin> Plugins => _plugins.AsReadOnly();

    public void LoadPlugins(string pluginsDirectory)
    {
        if (!Directory.Exists(pluginsDirectory))
        {
            ServerLog.Info("fourkit", $"Creating plugins directory: {pluginsDirectory}");
            Directory.CreateDirectory(pluginsDirectory);
            return;
        }

        var rootDlls = Directory.GetFiles(pluginsDirectory, "*.dll");
        if (rootDlls.Length > 0)
        {
            ServerLog.Info("fourkit", $"Found {rootDlls.Length} DLL(s) in plugins root.");
            foreach (var dll in rootDlls)
            {
                try { LoadPluginAssembly(dll); }
                catch (Exception ex) { ServerLog.Error("fourkit", $"Failed to load {Path.GetFileName(dll)}: {ex.Message}"); }
            }
        }

        foreach (var subDir in Directory.GetDirectories(pluginsDirectory))
        {
            string folderName = Path.GetFileName(subDir);
            var allDlls = Directory.GetFiles(subDir, "*.dll");
            if (allDlls.Length == 0)
                continue;

            string? mainDll = allDlls.FirstOrDefault(f =>
                string.Equals(Path.GetFileNameWithoutExtension(f), folderName, StringComparison.OrdinalIgnoreCase));

            if (mainDll != null)
            {
                try { LoadPluginAssembly(mainDll); }
                catch (Exception ex) { ServerLog.Error("fourkit", $"Failed to load {Path.GetFileName(mainDll)}: {ex.Message}"); }
            }
            else
            {
                foreach (var dll in allDlls)
                {
                    try { LoadPluginAssembly(dll); }
                    catch (Exception ex) { ServerLog.Error("fourkit", $"Failed to load {Path.GetFileName(dll)}: {ex.Message}"); }
                }
            }
        }
    }

    private void LoadPluginAssembly(string dllPath)
    {
        var context = new PluginLoadContext(dllPath);
        var assembly = context.LoadFromAssemblyPath(Path.GetFullPath(dllPath));

        int found = 0;
        foreach (var type in assembly.GetTypes())
        {
            if (type.IsAbstract || type.IsInterface)
                continue;

            if (!typeof(ServerPlugin).IsAssignableFrom(type))
                continue;

            var plugin = (ServerPlugin?)Activator.CreateInstance(type);
            if (plugin == null)
                continue;

            _plugins.Add(plugin);
            found++;

            string pName = GetPluginString(plugin, "name", "getName", "GetName", plugin.GetType().Name);
            string pVersion = GetPluginString(plugin, "version", "getVersion", "GetVersion", "1.0");
            string pAuthor = GetPluginString(plugin, "author", "getAuthor", "GetAuthor", "Unknown");

            if (!HasDeclaredMember(type, "name"))
                ServerLog.Warn("fourkit", $"Plugin {type.Name} does not declare a 'name' property.");
            if (!HasDeclaredMember(type, "version"))
                ServerLog.Warn("fourkit", $"Plugin {type.Name} does not declare a 'version' property.");
            if (!HasDeclaredMember(type, "author"))
                ServerLog.Warn("fourkit", $"Plugin {type.Name} does not declare an 'author' property.");

            ServerLog.Info("fourkit", $"Loaded plugin: {pName} v{pVersion} by {pAuthor}");
        }

        if (found == 0)
        {
            ServerLog.Warn("fourkit", $"No ServerPlugin classes found in {Path.GetFileName(dllPath)}");
        }
    }

    public void EnableAll()
    {
        foreach (var plugin in _plugins)
        {
            try
            {
                InvokePluginMethod(plugin, "onEnable", "OnEnable");
                string pName = GetPluginString(plugin, "name", "getName", "GetName", plugin.GetType().Name);
                ServerLog.Info("fourkit", $"Enabled: {pName}");
            }
            catch (Exception ex)
            {
                string pName = GetPluginString(plugin, "name", "getName", "GetName", plugin.GetType().Name);
                ServerLog.Error("fourkit", $"Error enabling {pName}: {ex.Message}");
            }
        }
    }

    public void DisableAll()
    {
        for (int i = _plugins.Count - 1; i >= 0; i--)
        {
            try
            {
                InvokePluginMethod(_plugins[i], "onDisable", "OnDisable");
                string pName = GetPluginString(_plugins[i], "name", "getName", "GetName", _plugins[i].GetType().Name);
                ServerLog.Info("fourkit", $"Disabled: {pName}");
            }
            catch (Exception ex)
            {
                string pName = GetPluginString(_plugins[i], "name", "getName", "GetName", _plugins[i].GetType().Name);
                ServerLog.Error("fourkit", $"Error disabling {pName}: {ex.Message}");
            }
        }
    }
    private static void InvokePluginMethod(ServerPlugin plugin, string camelName, string pascalName)
    {
        Type type = plugin.GetType();

        MethodInfo? method = type.GetMethod(camelName, DeclaredPublic, Type.EmptyTypes)
                          ?? type.GetMethod(pascalName, DeclaredPublic, Type.EmptyTypes);

        if (method != null)
        {
            method.Invoke(plugin, null);
        }
    }

    private static bool HasDeclaredMember(Type type, string name)
    {
        return type.GetProperty(name, DeclaredPublic) != null
            || type.GetMethod("get" + char.ToUpper(name[0]) + name[1..], DeclaredPublic, Type.EmptyTypes) != null;
    }

    private static string GetPluginString(
        ServerPlugin plugin, string propertyName,
        string getterCamel, string getterPascal,
        string fallback)
    {
        Type type = plugin.GetType();

        PropertyInfo? prop = type.GetProperty(propertyName, DeclaredPublic);
        if (prop != null && prop.PropertyType == typeof(string))
        {
            return (string?)prop.GetValue(plugin) ?? fallback;
        }

        MethodInfo? getter = type.GetMethod(getterCamel, DeclaredPublic, Type.EmptyTypes);
        if (getter != null && getter.ReturnType == typeof(string))
        {
            return (string?)getter.Invoke(plugin, null) ?? fallback;
        }

        getter = type.GetMethod(getterPascal, DeclaredPublic, Type.EmptyTypes);
        if (getter != null && getter.ReturnType == typeof(string))
        {
            return (string?)getter.Invoke(plugin, null) ?? fallback;
        }

        return fallback;
    }
}