PluginLoader.cs

/*
 * NanoXLSX is a small .NET library to generate and read XLSX (Microsoft Excel 2007 or newer) files in an easy and native way  
 * Copyright Raphael Stoeckli © 2026
 * This library is licensed under the MIT License.
 * You find a copy of the license in project folder or on: http://opensource.org/licenses/MIT
 */
 
using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;
using NanoXLSX.Interfaces;
using NanoXLSX.Interfaces.Writer;
using NanoXLSX.Registry.Attributes;
 
namespace NanoXLSX.Registry
{
    public static class PlugInLoader
    {
        private static bool initialized;
        private static readonly object _lock = new object();
 
        private static readonly Dictionary<string, PlugInInstance> plugInClasses = new Dictionary<string, PlugInInstance>();
        private static readonly Dictionary<string, List<PlugInInstance>> queuePlugInClasses = new Dictionary<string, List<PlugInInstance>>();

        public static bool Initialize()
        {
 
            if (initialized)
            {
                return false;
            }
            lock (_lock)
            {
                LoadReferencedAssemblies();
                initialized = true;
                return initialized;
            }
        }

        [ExcludeFromCodeCoverage] // Indirectly tested by InjectPlugins
        private static void LoadReferencedAssemblies()
        {
            Assembly[] loadedAssemblies = AppDomain.CurrentDomain.GetAssemblies();
 
            // 1. Register plugins from already-loaded assemblies
            foreach (Assembly assembly in loadedAssemblies)
            {
                if (!assembly.IsDynamic && !string.IsNullOrEmpty(assembly.Location))
                {
                    try
                    {
                        RegisterPlugIns(assembly);
                    }
                    catch (Exception ex)
                    {
                        System.Diagnostics.Debug.WriteLine($"Failed to register plugins from {assembly.Location}: {ex.Message}");
                    }
                }
            }
 
            // 2. Load any remaining DLLs that haven't been loaded yet
            IEnumerable<string> allLoadedPaths = loadedAssemblies
                .Where(a => !a.IsDynamic && !string.IsNullOrEmpty(a.Location))
                .Select(a => a.Location);
            HashSet<string> loadedPaths = new HashSet<string>(allLoadedPaths, StringComparer.InvariantCultureIgnoreCase);
 
            // Guard the assembly-directory enumeration. Directory.GetFiles can throw (e.g. IOException
            // "The parameter is incorrect" when BaseDirectory contains an entry the native enumerator
            // cannot stat). Phase 1 above already registered plugins from loaded assemblies,
            // so on enumeration failure, the already processed result is returned rather than crashing.
            List<string> referencedPaths;
            try
            {
                referencedPaths = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll")
                    .Where(path => !loadedPaths.Contains(path))
                    .ToList();
            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine($"Failed to enumerate assemblies in {AppDomain.CurrentDomain.BaseDirectory}: {ex.Message}");
                return;
            }
 
            foreach (string path in referencedPaths)
            {
                try
                {
                    Assembly assembly = Assembly.LoadFrom(path);
                    RegisterPlugIns(assembly);
                }
                catch (Exception ex)
                {
                    System.Diagnostics.Debug.WriteLine($"Failed to load assembly: {path} - {ex.Message}");
                }
            }
        }

        internal static void InjectPlugins(List<Type> pluginTypes)
        {
            lock (_lock)
            {
                // Collect all types decorated with the NanoXlsxPlugInAttribute.
                IEnumerable<Type> replacingPluginTypes = pluginTypes
                .Where(t => t.GetCustomAttribute<NanoXlsxPlugInAttribute>() != null);
 
                // Collect all types decorated with the NanoXlsxQueuePlugInAttribute.
                IEnumerable<Type> queuePluginTypes = pluginTypes
                    .Where(t => t.GetCustomAttributes<NanoXlsxQueuePlugInAttribute>().Any());
 
                // Pass the collected types to the appropriate handlers.
                HandleReplacingPlugIns(replacingPluginTypes);
                HandleQueuePlugIns(queuePluginTypes);
                initialized = true;
            }
        }

        internal static void DisposePlugins()
        {
            lock (_lock)
            {
                plugInClasses.Clear();
                queuePlugInClasses.Clear();
                initialized = false;
            }
        }

        [ExcludeFromCodeCoverage] // Indirectly tested by InjectPlugins
        private static void RegisterPlugIns(Assembly assembly)
        {
            IEnumerable<Type> replacingPlugInTypes = GetAssemblyPlugInsByType(assembly, typeof(NanoXlsxPlugInAttribute));
            IEnumerable<Type> queuePlugInTypes = GetAssemblyPlugInsByType(assembly, typeof(NanoXlsxQueuePlugInAttribute));
            HandleReplacingPlugIns(replacingPlugInTypes);
            HandleQueuePlugIns(queuePlugInTypes);
        }
 

        [ExcludeFromCodeCoverage] // Indirectly tested by InjectPlugins
        private static List<Type> GetAssemblyPlugInsByType(Assembly assembly, Type attributeType)
        {
            List<Type> plugInTypes = new List<Type>();
            Type plugInInterface = typeof(IPlugin);
            Type[] allTypes = assembly.GetTypes();
 
            for (int i = 0; i < allTypes.Length; i++)
            {
                Type type = allTypes[i];
                if (type.IsClass && !type.IsAbstract &&
                    plugInInterface.IsAssignableFrom(type) &&
                    type.GetCustomAttribute(attributeType) != null)
                {
                    plugInTypes.Add(type);
                }
            }
            return plugInTypes;
        }

        [ExcludeFromCodeCoverage] // Indirectly tested by InjectPlugins
        private static void HandleReplacingPlugIns(IEnumerable<Type> plugInTypes)
        {
            foreach (Type plugInType in plugInTypes)
            {
                IEnumerable<NanoXlsxPlugInAttribute> attributes = plugInType.GetCustomAttributes<NanoXlsxPlugInAttribute>();
                foreach (NanoXlsxPlugInAttribute attribute in attributes)
                {
                    if (plugInClasses.ContainsKey(attribute.PlugInUUID))
                    {
                        if (attribute.PlugInOrder >= plugInClasses[attribute.PlugInUUID].Order)
                        {
                            // Skip duplicates with lower order numbers
                            plugInClasses[attribute.PlugInUUID] = new PlugInInstance(attribute.PlugInUUID, attribute.PlugInOrder, plugInType);
                        }
                    }
                    else if (!plugInClasses.ContainsKey(attribute.PlugInUUID))
                    {
                        plugInClasses.Add(attribute.PlugInUUID, new PlugInInstance(attribute.PlugInUUID, attribute.PlugInOrder, plugInType));
                    }
                }
            }
        }

        private static void HandleQueuePlugIns(IEnumerable<Type> queuePlugInTypes)
        {
            foreach (Type plugInType in queuePlugInTypes)
            {
                IEnumerable<NanoXlsxQueuePlugInAttribute> attributes = plugInType.GetCustomAttributes<NanoXlsxQueuePlugInAttribute>();
                foreach (var attribute in attributes)
                {
                    if (!queuePlugInClasses.TryGetValue(attribute.QueueUUID, out var value))
                    {
                        value = new List<PlugInInstance>();
                        queuePlugInClasses.Add(attribute.QueueUUID, value);
                    }
 
                    value.Add(new PlugInInstance(attribute.PlugInUUID, attribute.PlugInOrder, plugInType));
                }
            }
            // Sort each list based on PlugInOrder (ascending)
            foreach (KeyValuePair<string, List<PlugInInstance>> entry in queuePlugInClasses)
            {
                entry.Value.Sort((a, b) => a.Order.CompareTo(b.Order));
            }
        }

        internal static T GetPlugIn<T>(string plugInUUID, T fallBackInstance)
        {
            if (plugInClasses.TryGetValue(plugInUUID, out var plugIn))
            {
                return (T)Activator.CreateInstance(plugIn.Type, true);
            }
            else
            {
                return fallBackInstance;
            }
        }

        internal static bool HasQueuePlugins(string queueUUID)
        {
            return queuePlugInClasses.TryGetValue(queueUUID, out var list) && list.Count > 0;
        }

        internal static T GetNextQueuePlugIn<T>(string queueUUID, string lastPlugInUUID, out string currentPlugInUUID)
            where T : class, IPlugin
        {
            return GetNextQueuePlugIn<T>(queueUUID, lastPlugInUUID, out currentPlugInUUID, null);
        }

        internal static T GetNextQueuePlugIn<T>(string queueUUID, string lastPlugInUUID, out string currentPlugInUUID, IBaseWriter baseWriter)
            where T : class, IPlugin
        {
            currentPlugInUUID = null;
            if (!queuePlugInClasses.TryGetValue(queueUUID, out var plugInList) || plugInList.Count == 0)
            {
                return default;
            }
 
            int startIndex = 0;
            if (lastPlugInUUID != null)
            {
                int lastIndex = plugInList.FindIndex(p => p.UUID == lastPlugInUUID);
                if (lastIndex < 0)
                {
                    return default;
                }
 
                startIndex = lastIndex + 1;
            }
 
            Type requestedType = typeof(T);
            for (int i = startIndex; i < plugInList.Count; i++)
            {
                PlugInInstance plugIn = plugInList[i];
                if (!requestedType.IsAssignableFrom(plugIn.Type))
                {
                    continue;
                }
 
                object instance = null;
                if (baseWriter != null)
                {
                    ConstructorInfo contextualConstructor = plugIn.Type
                        .GetConstructors(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
                        .FirstOrDefault(constructor =>
                        {
                            ParameterInfo[] parameters = constructor.GetParameters();
                            return parameters.Length == 1 && parameters[0].ParameterType == typeof(IBaseWriter);
                        });
                    if (contextualConstructor != null)
                    {
                        instance = contextualConstructor.Invoke(new object[] { baseWriter });
                    }
                }
 
                if (instance == null)
                {
                    instance = Activator.CreateInstance(plugIn.Type, true);
                }
 
                currentPlugInUUID = plugIn.UUID;
                return (T)instance;
            }
 
            return default;
        }

        private sealed class PlugInInstance
        {
            public string UUID { get; private set; }
            public int Order { get; private set; }
            public Type Type { get; private set; }

            internal PlugInInstance(string uuid, int order, Type type)
            {
                this.UUID = uuid;
                this.Order = order;
                this.Type = type;
            }
        }
    }
}