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.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);
 
            List<string> referencedPaths = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, "*.dll")
                .Where(path => !loadedPaths.Contains(path))
                .ToList();
 
            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 T GetNextQueuePlugIn<T>(string queueUUID, string lastPlugInUUID, out string currentPlugInUUID)
        {
            if (queuePlugInClasses.TryGetValue(queueUUID, out var plugInList) && plugInList.Count > 0)
            {
                PlugInInstance plugIn = null;
                if (lastPlugInUUID == null)
                {
                    plugIn = plugInList[0];
                }
                else
                {
                    // Find the next plug-in after the currentPlugInUUID
                    int index = plugInList.FindIndex(p => p.UUID == lastPlugInUUID);
                    if (index >= 0 && index + 1 < plugInList.Count)
                    {
                        plugIn = plugInList[index + 1]; // Get the next plug-in in the list
                    }
                }
                if (plugIn == null)
                {
                    currentPlugInUUID = null;
                    return default;
                }
                currentPlugInUUID = plugIn.UUID;
                return (T)Activator.CreateInstance(plugIn.Type, true);
            }
            else
            {
                currentPlugInUUID = null;
                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;
            }
        }
    }
}